Section 1
//b2CircleDef (Box2D.Collision.Shapes.b2CircleDef)
package Box2D.Collision.Shapes {
	import Box2D.Common.Math.*;

	public class b2CircleDef extends b2ShapeDef {

		public var radius:Number;
		public var localPosition:b2Vec2;

		public function b2CircleDef(){
			localPosition = new b2Vec2(0, 0);
			super();
			type = b2Shape.e_circleShape;
			radius = 1;
		}
	}
}//package Box2D.Collision.Shapes 
Section 2
//b2CircleShape (Box2D.Collision.Shapes.b2CircleShape)
package Box2D.Collision.Shapes {
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2CircleShape extends b2Shape {

		public var m_localPosition:b2Vec2;
		public var m_radius:Number;

		public function b2CircleShape(def:b2ShapeDef){
			m_localPosition = new b2Vec2();
			super(def);
			var circleDef:b2CircleDef = (def as b2CircleDef);
			m_type = e_circleShape;
			m_localPosition.SetV(circleDef.localPosition);
			m_radius = circleDef.radius;
		}
		override public function TestSegment(transform:b2XForm, lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			var sY:Number;
			var tMat:b2Mat22 = transform.R;
			var positionX:Number = (transform.position.x + ((tMat.col1.x * m_localPosition.x) + (tMat.col2.x * m_localPosition.y)));
			var positionY:Number = (transform.position.x + ((tMat.col1.y * m_localPosition.x) + (tMat.col2.y * m_localPosition.y)));
			var sX:Number = (segment.p1.x - positionX);
			sY = (segment.p1.y - positionY);
			var b:Number = (((sX * sX) + (sY * sY)) - (m_radius * m_radius));
			if (b < 0){
				return (false);
			};
			var rX:Number = (segment.p2.x - segment.p1.x);
			var rY:Number = (segment.p2.y - segment.p1.y);
			var c:Number = ((sX * rX) + (sY * rY));
			var rr:Number = ((rX * rX) + (rY * rY));
			var sigma:Number = ((c * c) - (rr * b));
			if ((((sigma < 0)) || ((rr < Number.MIN_VALUE)))){
				return (false);
			};
			var a:Number = -((c + Math.sqrt(sigma)));
			if ((((0 <= a)) && ((a <= (maxLambda * rr))))){
				a = (a / rr);
				lambda[0] = a;
				normal.x = (sX + (a * rX));
				normal.y = (sY + (a * rY));
				normal.Normalize();
				return (true);
			};
			return (false);
		}
		public function GetLocalPosition():b2Vec2{
			return (m_localPosition);
		}
		public function GetRadius():Number{
			return (m_radius);
		}
		override public function ComputeSweptAABB(aabb:b2AABB, transform1:b2XForm, transform2:b2XForm):void{
			var tMat:b2Mat22;
			tMat = transform1.R;
			var p1X:Number = (transform1.position.x + ((tMat.col1.x * m_localPosition.x) + (tMat.col2.x * m_localPosition.y)));
			var p1Y:Number = (transform1.position.y + ((tMat.col1.y * m_localPosition.x) + (tMat.col2.y * m_localPosition.y)));
			tMat = transform2.R;
			var p2X:Number = (transform2.position.x + ((tMat.col1.x * m_localPosition.x) + (tMat.col2.x * m_localPosition.y)));
			var p2Y:Number = (transform2.position.y + ((tMat.col1.y * m_localPosition.x) + (tMat.col2.y * m_localPosition.y)));
			aabb.lowerBound.Set((((p1X < p2X)) ? p1X : p2X - m_radius), (((p1Y < p2Y)) ? p1Y : p2Y - m_radius));
			aabb.upperBound.Set((((p1X > p2X)) ? p1X : p2X + m_radius), (((p1Y > p2Y)) ? p1Y : p2Y + m_radius));
		}
		override public function ComputeMass(massData:b2MassData):void{
			massData.mass = (((m_density * b2Settings.b2_pi) * m_radius) * m_radius);
			massData.center.SetV(m_localPosition);
			massData.I = (massData.mass * (((0.5 * m_radius) * m_radius) + ((m_localPosition.x * m_localPosition.x) + (m_localPosition.y * m_localPosition.y))));
		}
		override public function UpdateSweepRadius(center:b2Vec2):void{
			var dX:Number = (m_localPosition.x - center.x);
			var dY:Number = (m_localPosition.y - center.y);
			dX = Math.sqrt(((dX * dX) + (dY * dY)));
			m_sweepRadius = ((dX + m_radius) - b2Settings.b2_toiSlop);
		}
		override public function ComputeAABB(aabb:b2AABB, transform:b2XForm):void{
			var tMat:b2Mat22 = transform.R;
			var pX:Number = (transform.position.x + ((tMat.col1.x * m_localPosition.x) + (tMat.col2.x * m_localPosition.y)));
			var pY:Number = (transform.position.y + ((tMat.col1.y * m_localPosition.x) + (tMat.col2.y * m_localPosition.y)));
			aabb.lowerBound.Set((pX - m_radius), (pY - m_radius));
			aabb.upperBound.Set((pX + m_radius), (pY + m_radius));
		}
		override public function TestPoint(transform:b2XForm, p:b2Vec2):Boolean{
			var tMat:b2Mat22 = transform.R;
			var dX:Number = (transform.position.x + ((tMat.col1.x * m_localPosition.x) + (tMat.col2.x * m_localPosition.y)));
			var dY:Number = (transform.position.y + ((tMat.col1.y * m_localPosition.x) + (tMat.col2.y * m_localPosition.y)));
			dX = (p.x - dX);
			dY = (p.y - dY);
			return ((((dX * dX) + (dY * dY)) <= (m_radius * m_radius)));
		}

	}
}//package Box2D.Collision.Shapes 
Section 3
//b2ConcaveArcDef (Box2D.Collision.Shapes.b2ConcaveArcDef)
package Box2D.Collision.Shapes {

	public class b2ConcaveArcDef extends b2PolygonDef {

		public var radius:Number;

		public function b2ConcaveArcDef(){
			super();
			type = b2Shape.e_concaveArcShape;
			radius = 1;
		}
	}
}//package Box2D.Collision.Shapes 
Section 4
//b2ConcaveArcShape (Box2D.Collision.Shapes.b2ConcaveArcShape)
package Box2D.Collision.Shapes {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2ConcaveArcShape extends b2PolygonShape {

		public var m_radius:Number;
		public var m_radius2:Number;
		public var m_arcCenter:b2Vec2;
		public var m_dot:Number;
		public var m_norm:Number;

		public function b2ConcaveArcShape(def:b2ShapeDef){
			var nx:Number;
			var ny:Number;
			super(def);
			var arcDef:b2ConcaveArcDef = (def as b2ConcaveArcDef);
			m_radius = arcDef.radius;
			m_radius2 = (m_radius * m_radius);
			var p1:b2Vec2 = m_vertices[0];
			var p2:b2Vec2 = m_vertices[1];
			var dx:Number = (p1.x - p2.x);
			var dy:Number = (p1.y - p2.y);
			var d2:Number = ((dx * dx) + (dy * dy));
			var d:Number = Math.sqrt(d2);
			if ((d2 / 4) > m_radius2){
				m_radius2 = (d2 / 4);
				m_radius = (d / 2);
			};
			var dot:Number = Math.sqrt((m_radius2 - (d2 * 0.25)));
			m_arcCenter = new b2Vec2((((p1.x + p2.x) / 2) + (dot * m_normals[0].x)), (((p1.y + p2.y) / 2) + (dot * m_normals[0].y)));
			m_dot = (dot / m_radius);
			m_norm = ((d / 2) / m_radius);
			var coreRadius2:Number = ((m_radius + b2Settings.b2_toiSlop) * (m_radius + b2Settings.b2_toiSlop));
			nx = m_normals[(m_vertexCount - 1)].x;
			ny = m_normals[(m_vertexCount - 1)].y;
			dx = (m_coreVertices[0].x - m_arcCenter.x);
			dy = (m_coreVertices[0].y - m_arcCenter.y);
			d = ((dx * nx) + (dy * ny));
			d2 = Math.sqrt((coreRadius2 - (d * d)));
			m_coreVertices[0].x = ((m_arcCenter.x + (d * nx)) + (d2 * ny));
			m_coreVertices[0].y = ((m_arcCenter.y + (d * ny)) - (d2 * nx));
			nx = m_normals[1].x;
			ny = m_normals[1].y;
			dx = (m_coreVertices[1].x - m_arcCenter.x);
			dy = (m_coreVertices[1].y - m_arcCenter.y);
			d = ((dx * nx) + (dy * ny));
			d2 = Math.sqrt((coreRadius2 - (d * d)));
			m_coreVertices[1].x = ((m_arcCenter.x + (d * nx)) - (d2 * ny));
			m_coreVertices[1].y = ((m_arcCenter.y + (d * ny)) + (d2 * nx));
			m_type = b2Shape.e_concaveArcShape;
		}
		override public function TestSegment(xf:b2XForm, lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			b2Settings.b2Assert(false);
			return (false);
		}
		override public function ComputeMass(massData:b2MassData):void{
			super.ComputeMass(massData);
		}
		override public function TestPoint(xf:b2XForm, p:b2Vec2):Boolean{
			var tVec:b2Vec2;
			var dot:Number;
			var tMat:b2Mat22 = xf.R;
			var tX:Number = (p.x - xf.position.x);
			var tY:Number = (p.y - xf.position.y);
			var pLocalX:Number = ((tX * tMat.col1.x) + (tY * tMat.col1.y));
			var pLocalY:Number = ((tX * tMat.col2.x) + (tY * tMat.col2.y));
			var i:int;
			while (i < m_vertexCount) {
				tVec = m_vertices[i];
				tX = (pLocalX - tVec.x);
				tY = (pLocalY - tVec.y);
				dot = ((tVec.x * tX) + (tVec.y * tY));
				if (dot > 0){
					return (false);
				};
				i++;
			};
			tX = (pLocalX - m_arcCenter.x);
			tY = (pLocalY - m_arcCenter.y);
			return ((((tX * tX) + (tY * tY)) > m_radius2));
		}

		public static function TriangleMass(massData:b2MassData, p1:b2Vec2, p2:b2Vec2, p3:b2Vec2, density:Number):void{
			var k_inv3:Number;
			var e1X:Number;
			var e1Y:Number;
			var e2X:Number;
			var e2Y:Number;
			var D:Number;
			k_inv3 = (1 / 3);
			e1X = (p2.x - p1.x);
			e1Y = (p2.y - p1.y);
			e2X = (p3.x - p1.x);
			e2Y = (p3.y - p1.y);
			D = ((e1X * e2Y) - (e1Y * e2X));
			var triangleArea:Number = (0.5 * D);
			massData.mass = (triangleArea * density);
			massData.center.x = (k_inv3 * ((p1.x + p2.x) + p3.x));
			massData.center.y = (k_inv3 * ((p1.y + p2.y) + p3.y));
			var px:Number = p1.x;
			var py:Number = p1.y;
			var ex1:Number = e1X;
			var ey1:Number = e1Y;
			var ex2:Number = e2X;
			var ey2:Number = e2Y;
			var intx2:Number = ((k_inv3 * ((0.25 * (((ex1 * ex1) + (ex2 * ex1)) + (ex2 * ex2))) + ((px * ex1) + (px * ex2)))) + ((0.5 * px) * px));
			var inty2:Number = ((k_inv3 * ((0.25 * (((ey1 * ey1) + (ey2 * ey1)) + (ey2 * ey2))) + ((py * ey1) + (py * ey2)))) + ((0.5 * py) * py));
			massData.I = ((D * (intx2 + inty2)) * density);
		}
		public static function SegmentMass(massData:b2MassData, arcCenter:b2Vec2, radius:Number, norm:b2Vec2, d:Number, density:Number):void{
			var theta:Number;
			theta = (Math.asin(((d / radius) / 2)) * 2);
			massData.mass = ((((0.5 * radius) * radius) * theta) * density);
			var v:Number = (((2 / 3) * d) / theta);
			if (theta < Number.MIN_VALUE){
				v = ((2 / 3) * radius);
			};
			massData.center = new b2Vec2((arcCenter.x - (norm.x * v)), (arcCenter.y - (norm.y * v)));
			massData.I = ((((0.5 * massData.mass) * radius) * radius) - ((massData.mass * v) * v));
		}

	}
}//package Box2D.Collision.Shapes 
Section 5
//b2ConvexArcShape (Box2D.Collision.Shapes.b2ConvexArcShape)
package Box2D.Collision.Shapes {
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2ConvexArcShape extends b2Shape {

		public var m_localPosition:b2Vec2;
		public var m_offset:Number;
		public var m_norm:b2Vec2;
		public var m_dot:Number;
		public var m_vertices:Array;
		public var m_d:Number;
		public var m_radius:Number;
		public var m_obb:b2OBB;

		public function b2ConvexArcShape(def:b2ShapeDef){
			m_localPosition = new b2Vec2();
			m_obb = new b2OBB();
			m_vertices = [new b2Vec2(), new b2Vec2()];
			m_norm = new b2Vec2();
			super(def);
		}
		override public function TestSegment(xf:b2XForm, lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			b2Settings.b2Assert(false);
			return (false);
		}
		override public function ComputeMass(massData:b2MassData):void{
		}
		override public function ComputeSweptAABB(aabb:b2AABB, transform1:b2XForm, transform2:b2XForm):void{
			super.ComputeSweptAABB(aabb, transform1, transform2);
		}
		public function Support(xf:b2XForm, dX:Number, dY:Number):b2Vec2{
			b2Settings.b2Assert(false);
			return (null);
		}
		override public function UpdateSweepRadius(center:b2Vec2):void{
		}
		override public function ComputeAABB(aabb:b2AABB, xf:b2XForm):void{
			super.ComputeAABB(aabb, xf);
		}
		public function GetOBB():b2OBB{
			return (m_obb);
		}
		override public function TestPoint(xf:b2XForm, p:b2Vec2):Boolean{
			b2Settings.b2Assert(false);
			return (false);
		}

	}
}//package Box2D.Collision.Shapes 
Section 6
//b2FilterData (Box2D.Collision.Shapes.b2FilterData)
package Box2D.Collision.Shapes {

	public class b2FilterData {

		public var maskBits:uint;// = 0xFFFF
		public var groupIndex:int;// = 0
		public var categoryBits:uint;// = 1

		public function b2FilterData(){
			super();
		}
		public function Copy():b2FilterData{
			var copy:b2FilterData = new b2FilterData();
			copy.categoryBits = categoryBits;
			copy.maskBits = maskBits;
			copy.groupIndex = groupIndex;
			return (copy);
		}

	}
}//package Box2D.Collision.Shapes 
Section 7
//b2MassData (Box2D.Collision.Shapes.b2MassData)
package Box2D.Collision.Shapes {
	import Box2D.Common.Math.*;

	public class b2MassData {

		public var mass:Number;// = 0
		public var center:b2Vec2;
		public var I:Number;// = 0

		public function b2MassData(){
			center = new b2Vec2(0, 0);
			super();
		}
		public function Set(massData:b2MassData):void{
			mass = massData.mass;
			center.x = massData.center.x;
			center.y = massData.center.y;
			I = massData.I;
		}

		public static function Add(... _args):b2MassData{
			var massData:b2MassData;
			var r:b2Vec2;
			var finalMass:b2MassData = new (b2MassData);
			for each (massData in _args) {
				finalMass.mass = (finalMass.mass + massData.mass);
			};
			if (Math.abs(finalMass.mass) > Number.MIN_VALUE){
				for each (massData in _args) {
					finalMass.center.x = (finalMass.center.x + (massData.mass * massData.center.x));
					finalMass.center.y = (finalMass.center.y + (massData.mass * massData.center.y));
				};
				finalMass.center.x = (finalMass.center.x / finalMass.mass);
				finalMass.center.y = (finalMass.center.y / finalMass.mass);
				for each (massData in _args) {
					finalMass.I = (finalMass.I + massData.I);
					r = b2Math.SubtractVV(massData.center, finalMass.center);
					finalMass.I = (finalMass.I + (massData.mass * b2Math.b2Dot(r, r)));
				};
			};
			return (finalMass);
		}

	}
}//package Box2D.Collision.Shapes 
Section 8
//b2PolygonDef (Box2D.Collision.Shapes.b2PolygonDef)
package Box2D.Collision.Shapes {
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2PolygonDef extends b2ShapeDef {

		public var vertices:Array;
		public var vertexCount:int;

		private static var s_mat:b2Mat22 = new b2Mat22();

		public function b2PolygonDef(){
			vertices = new Array(b2Settings.b2_maxPolygonVertices);
			super();
			type = b2Shape.e_polygonShape;
			vertexCount = 0;
			var i:int;
			while (i < b2Settings.b2_maxPolygonVertices) {
				vertices[i] = new b2Vec2();
				i++;
			};
		}
		public function SetAsBox(hx:Number, hy:Number):void{
			vertexCount = 4;
			vertices[0].Set(-(hx), -(hy));
			vertices[1].Set(hx, -(hy));
			vertices[2].Set(hx, hy);
			vertices[3].Set(-(hx), hy);
		}
		public function SetAsOrientedBox(hx:Number, hy:Number, center:b2Vec2=null, angle:Number=0):void{
			var xfPosition:b2Vec2;
			var xfR:b2Mat22;
			var i:int;
			vertexCount = 4;
			vertices[0].Set(-(hx), -(hy));
			vertices[1].Set(hx, -(hy));
			vertices[2].Set(hx, hy);
			vertices[3].Set(-(hx), hy);
			if (center){
				xfPosition = center;
				xfR = s_mat;
				xfR.Set(angle);
				i = 0;
				while (i < vertexCount) {
					center = vertices[i];
					hx = (xfPosition.x + ((xfR.col1.x * center.x) + (xfR.col2.x * center.y)));
					center.y = (xfPosition.y + ((xfR.col1.y * center.x) + (xfR.col2.y * center.y)));
					center.x = hx;
					i++;
				};
			};
		}
		public function SetAsZShape(shapeDef:Array):void{
			vertexCount = shapeDef.length;
			var i:int;
			while (i < shapeDef.length) {
				if (shapeDef[i] != null){
					vertices[i].Set(shapeDef[i].x, shapeDef[i].y);
				};
				i++;
			};
		}

	}
}//package Box2D.Collision.Shapes 
Section 9
//b2PolygonShape (Box2D.Collision.Shapes.b2PolygonShape)
package Box2D.Collision.Shapes {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2PolygonShape extends b2Shape {

		public var m_coreVertices:Array;
		public var m_vertices:Array;
		private var s_supportVec:b2Vec2;
		public var m_centroid:b2Vec2;
		public var m_normals:Array;
		public var m_obb:b2OBB;
		public var m_vertexCount:int;

		private static var s_computeMat:b2Mat22 = new b2Mat22();
		private static var s_sweptAABB1:b2AABB = new b2AABB();
		private static var s_sweptAABB2:b2AABB = new b2AABB();

		public function b2PolygonShape(def:b2ShapeDef){
			var i:int;
			var edgeX:Number;
			var edgeY:Number;
			var len:Number;
			var n1X:Number;
			var n1Y:Number;
			var n2X:Number;
			var n2Y:Number;
			var vX:Number;
			var vY:Number;
			var dX:Number;
			var dY:Number;
			var det:Number;
			s_supportVec = new b2Vec2();
			m_obb = new b2OBB();
			m_vertices = new Array(b2Settings.b2_maxPolygonVertices);
			m_normals = new Array(b2Settings.b2_maxPolygonVertices);
			m_coreVertices = new Array(b2Settings.b2_maxPolygonVertices);
			super(def);
			m_type = e_polygonShape;
			var poly:b2PolygonDef = (def as b2PolygonDef);
			m_vertexCount = poly.vertexCount;
			var i1:int = i;
			var i2:int = i;
			i = 0;
			while (i < m_vertexCount) {
				m_vertices[i] = poly.vertices[i].Copy();
				i++;
			};
			i = 0;
			while (i < m_vertexCount) {
				i1 = i;
				i2 = (((i + 1) < m_vertexCount)) ? (i + 1) : 0;
				edgeX = (m_vertices[i2].x - m_vertices[i1].x);
				edgeY = (m_vertices[i2].y - m_vertices[i1].y);
				len = Math.sqrt(((edgeX * edgeX) + (edgeY * edgeY)));
				m_normals[i] = new b2Vec2((edgeY / len), (-(edgeX) / len));
				i++;
			};
			m_centroid = ComputeCentroid(poly.vertices, poly.vertexCount);
			ComputeOBB(m_obb, m_vertices, m_vertexCount);
			i = 0;
			while (i < m_vertexCount) {
				i1 = (((i - 1) >= 0)) ? (i - 1) : (m_vertexCount - 1);
				i2 = i;
				n1X = m_normals[i1].x;
				n1Y = m_normals[i1].y;
				n2X = m_normals[i2].x;
				n2Y = m_normals[i2].y;
				vX = (m_vertices[i].x - m_centroid.x);
				vY = (m_vertices[i].y - m_centroid.y);
				dX = (((n1X * vX) + (n1Y * vY)) - b2Settings.b2_toiSlop);
				dY = (((n2X * vX) + (n2Y * vY)) - b2Settings.b2_toiSlop);
				det = (1 / ((n1X * n2Y) - (n1Y * n2X)));
				m_coreVertices[i] = new b2Vec2(((det * ((n2Y * dX) - (n1Y * dY))) + m_centroid.x), ((det * ((n1X * dY) - (n2X * dX))) + m_centroid.y));
				i++;
			};
		}
		override public function ComputeSweptAABB(aabb:b2AABB, transform1:b2XForm, transform2:b2XForm):void{
			var aabb1:b2AABB = s_sweptAABB1;
			var aabb2:b2AABB = s_sweptAABB2;
			ComputeAABB(aabb1, transform1);
			ComputeAABB(aabb2, transform2);
			aabb.lowerBound.Set(((aabb1.lowerBound.x < aabb2.lowerBound.x)) ? aabb1.lowerBound.x : aabb2.lowerBound.x, ((aabb1.lowerBound.y < aabb2.lowerBound.y)) ? aabb1.lowerBound.y : aabb2.lowerBound.y);
			aabb.upperBound.Set(((aabb1.upperBound.x > aabb2.upperBound.x)) ? aabb1.upperBound.x : aabb2.upperBound.x, ((aabb1.upperBound.y > aabb2.upperBound.y)) ? aabb1.upperBound.y : aabb2.upperBound.y);
		}
		public function GetVertices():Array{
			return (m_vertices);
		}
		public function GetCoreVertices():Array{
			return (m_coreVertices);
		}
		public function GetCentroid():b2Vec2{
			return (m_centroid);
		}
		public function GetOBB():b2OBB{
			return (m_obb);
		}
		public function GetFirstVertex(xf:b2XForm):b2Vec2{
			return (b2Math.b2MulX(xf, m_coreVertices[0]));
		}
		public function Centroid(xf:b2XForm):b2Vec2{
			return (b2Math.b2MulX(xf, m_centroid));
		}
		override public function TestSegment(xf:b2XForm, lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			var tX:Number;
			var tY:Number;
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var numerator:Number;
			var denominator:Number;
			var lower:Number = 0;
			var upper:Number = maxLambda;
			tX = (segment.p1.x - xf.position.x);
			tY = (segment.p1.y - xf.position.y);
			tMat = xf.R;
			var p1X:Number = ((tX * tMat.col1.x) + (tY * tMat.col1.y));
			var p1Y:Number = ((tX * tMat.col2.x) + (tY * tMat.col2.y));
			tX = (segment.p2.x - xf.position.x);
			tY = (segment.p2.y - xf.position.y);
			tMat = xf.R;
			var p2X:Number = ((tX * tMat.col1.x) + (tY * tMat.col1.y));
			var p2Y:Number = ((tX * tMat.col2.x) + (tY * tMat.col2.y));
			var dX:Number = (p2X - p1X);
			var dY:Number = (p2Y - p1Y);
			var index = -1;
			var i:int;
			while (i < m_vertexCount) {
				tVec = m_vertices[i];
				tX = (tVec.x - p1X);
				tY = (tVec.y - p1Y);
				tVec = m_normals[i];
				numerator = ((tVec.x * tX) + (tVec.y * tY));
				denominator = ((tVec.x * dX) + (tVec.y * dY));
				if ((((denominator < 0)) && ((numerator < (lower * denominator))))){
					lower = (numerator / denominator);
					index = i;
				} else {
					if ((((denominator > 0)) && ((numerator < (upper * denominator))))){
						upper = (numerator / denominator);
					};
				};
				if (upper < lower){
					return (false);
				};
				i++;
			};
			if (index >= 0){
				lambda[0] = lower;
				tMat = xf.R;
				tVec = m_normals[index];
				normal.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
				normal.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
				return (true);
			};
			return (false);
		}
		override public function ComputeMass(massData:b2MassData):void{
			var p2:b2Vec2;
			var p3:b2Vec2;
			var e1X:Number;
			var e1Y:Number;
			var e2X:Number;
			var e2Y:Number;
			var D:Number;
			var triangleArea:Number;
			var px:Number;
			var py:Number;
			var ex1:Number;
			var ey1:Number;
			var ex2:Number;
			var ey2:Number;
			var intx2:Number;
			var inty2:Number;
			var centerX:Number = 0;
			var centerY:Number = 0;
			var area:Number = 0;
			var I:Number = 0;
			var p1X:Number = 0;
			var p1Y:Number = 0;
			var k_inv3:Number = (1 / 3);
			var i:int;
			while (i < m_vertexCount) {
				p2 = m_vertices[i];
				p3 = (((i + 1) < m_vertexCount)) ? m_vertices[int((i + 1))] : m_vertices[0];
				e1X = (p2.x - p1X);
				e1Y = (p2.y - p1Y);
				e2X = (p3.x - p1X);
				e2Y = (p3.y - p1Y);
				D = ((e1X * e2Y) - (e1Y * e2X));
				triangleArea = (0.5 * D);
				area = (area + triangleArea);
				centerX = (centerX + ((triangleArea * k_inv3) * ((p1X + p2.x) + p3.x)));
				centerY = (centerY + ((triangleArea * k_inv3) * ((p1Y + p2.y) + p3.y)));
				px = p1X;
				py = p1Y;
				ex1 = e1X;
				ey1 = e1Y;
				ex2 = e2X;
				ey2 = e2Y;
				intx2 = ((k_inv3 * ((0.25 * (((ex1 * ex1) + (ex2 * ex1)) + (ex2 * ex2))) + ((px * ex1) + (px * ex2)))) + ((0.5 * px) * px));
				inty2 = ((k_inv3 * ((0.25 * (((ey1 * ey1) + (ey2 * ey1)) + (ey2 * ey2))) + ((py * ey1) + (py * ey2)))) + ((0.5 * py) * py));
				I = (I + (D * (intx2 + inty2)));
				i++;
			};
			massData.mass = (m_density * area);
			centerX = (centerX * (1 / area));
			centerY = (centerY * (1 / area));
			massData.center.Set(centerX, centerY);
			massData.I = (m_density * I);
		}
		public function GetNormals():Array{
			return (m_normals);
		}
		public function Support(xf:b2XForm, dX:Number, dY:Number):b2Vec2{
			var tVec:b2Vec2;
			var tMat:b2Mat22;
			var value:Number;
			tMat = xf.R;
			var dLocalX:Number = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			var dLocalY:Number = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			var bestIndex:int;
			tVec = m_coreVertices[0];
			var bestValue:Number = ((tVec.x * dLocalX) + (tVec.y * dLocalY));
			var i = 1;
			while (i < m_vertexCount) {
				tVec = m_coreVertices[i];
				value = ((tVec.x * dLocalX) + (tVec.y * dLocalY));
				if (value > bestValue){
					bestIndex = i;
					bestValue = value;
				};
				i++;
			};
			tMat = xf.R;
			tVec = m_coreVertices[bestIndex];
			s_supportVec.x = (xf.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			s_supportVec.y = (xf.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			return (s_supportVec);
		}
		public function GetVertexCount():int{
			return (m_vertexCount);
		}
		override public function ComputeAABB(aabb:b2AABB, xf:b2XForm):void{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var R:b2Mat22 = s_computeMat;
			tMat = xf.R;
			tVec = m_obb.R.col1;
			R.col1.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			R.col1.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			tVec = m_obb.R.col2;
			R.col2.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			R.col2.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			R.Abs();
			var absR:b2Mat22 = R;
			tVec = m_obb.extents;
			var hX:Number = ((absR.col1.x * tVec.x) + (absR.col2.x * tVec.y));
			var hY:Number = ((absR.col1.y * tVec.x) + (absR.col2.y * tVec.y));
			tMat = xf.R;
			tVec = m_obb.center;
			var positionX:Number = (xf.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var positionY:Number = (xf.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			aabb.lowerBound.Set((positionX - hX), (positionY - hY));
			aabb.upperBound.Set((positionX + hX), (positionY + hY));
		}
		override public function UpdateSweepRadius(center:b2Vec2):void{
			var tVec:b2Vec2;
			var dX:Number;
			var dY:Number;
			m_sweepRadius = 0;
			var i:int;
			while (i < m_vertexCount) {
				tVec = m_coreVertices[i];
				dX = (tVec.x - center.x);
				dY = (tVec.y - center.y);
				dX = Math.sqrt(((dX * dX) + (dY * dY)));
				if (dX > m_sweepRadius){
					m_sweepRadius = dX;
				};
				i++;
			};
		}
		override public function TestPoint(xf:b2XForm, p:b2Vec2):Boolean{
			var tVec:b2Vec2;
			var dot:Number;
			var tMat:b2Mat22 = xf.R;
			var tX:Number = (p.x - xf.position.x);
			var tY:Number = (p.y - xf.position.y);
			var pLocalX:Number = ((tX * tMat.col1.x) + (tY * tMat.col1.y));
			var pLocalY:Number = ((tX * tMat.col2.x) + (tY * tMat.col2.y));
			var i:int;
			while (i < m_vertexCount) {
				tVec = m_vertices[i];
				tX = (pLocalX - tVec.x);
				tY = (pLocalY - tVec.y);
				tVec = m_normals[i];
				dot = ((tVec.x * tX) + (tVec.y * tY));
				if (dot > 0){
					return (false);
				};
				i++;
			};
			return (true);
		}

		public static function ComputeCentroid(vs:Array, count:int):b2Vec2{
			var c:b2Vec2;
			var inv3:Number;
			var p2:b2Vec2;
			var p3:b2Vec2;
			var e1X:Number;
			var e1Y:Number;
			var e2X:Number;
			var e2Y:Number;
			var D:Number;
			var triangleArea:Number;
			c = new b2Vec2();
			var area:Number = 0;
			var p1X:Number = 0;
			var p1Y:Number = 0;
			inv3 = (1 / 3);
			var i:int;
			while (i < count) {
				p2 = vs[i];
				p3 = (((i + 1) < count)) ? vs[int((i + 1))] : vs[0];
				e1X = (p2.x - p1X);
				e1Y = (p2.y - p1Y);
				e2X = (p3.x - p1X);
				e2Y = (p3.y - p1Y);
				D = ((e1X * e2Y) - (e1Y * e2X));
				triangleArea = (0.5 * D);
				area = (area + triangleArea);
				c.x = (c.x + ((triangleArea * inv3) * ((p1X + p2.x) + p3.x)));
				c.y = (c.y + ((triangleArea * inv3) * ((p1Y + p2.y) + p3.y)));
				i++;
			};
			c.x = (c.x * (1 / area));
			c.y = (c.y * (1 / area));
			return (c);
		}
		public static function ComputeOBB(obb:b2OBB, vs:Array, count:int):void{
			var i:int;
			var root:b2Vec2;
			var uxX:Number;
			var uxY:Number;
			var length:Number;
			var uyX:Number;
			var uyY:Number;
			var lowerX:Number;
			var lowerY:Number;
			var upperX:Number;
			var upperY:Number;
			var j:int;
			var area:Number;
			var dX:Number;
			var dY:Number;
			var rX:Number;
			var rY:Number;
			var centerX:Number;
			var centerY:Number;
			var tMat:b2Mat22;
			var p:Array = new Array((b2Settings.b2_maxPolygonVertices + 1));
			i = 0;
			while (i < count) {
				p[i] = vs[i];
				i++;
			};
			p[count] = p[0];
			var minArea:Number = Number.MAX_VALUE;
			i = 1;
			while (i <= count) {
				root = p[int((i - 1))];
				uxX = (p[i].x - root.x);
				uxY = (p[i].y - root.y);
				length = Math.sqrt(((uxX * uxX) + (uxY * uxY)));
				uxX = (uxX / length);
				uxY = (uxY / length);
				uyX = -(uxY);
				uyY = uxX;
				lowerX = Number.MAX_VALUE;
				lowerY = Number.MAX_VALUE;
				upperX = -(Number.MAX_VALUE);
				upperY = -(Number.MAX_VALUE);
				j = 0;
				while (j < count) {
					dX = (p[j].x - root.x);
					dY = (p[j].y - root.y);
					rX = ((uxX * dX) + (uxY * dY));
					rY = ((uyX * dX) + (uyY * dY));
					if (rX < lowerX){
						lowerX = rX;
					};
					if (rY < lowerY){
						lowerY = rY;
					};
					if (rX > upperX){
						upperX = rX;
					};
					if (rY > upperY){
						upperY = rY;
					};
					j++;
				};
				area = ((upperX - lowerX) * (upperY - lowerY));
				if (area < (0.95 * minArea)){
					minArea = area;
					obb.R.col1.x = uxX;
					obb.R.col1.y = uxY;
					obb.R.col2.x = uyX;
					obb.R.col2.y = uyY;
					centerX = (0.5 * (lowerX + upperX));
					centerY = (0.5 * (lowerY + upperY));
					tMat = obb.R;
					obb.center.x = (root.x + ((tMat.col1.x * centerX) + (tMat.col2.x * centerY)));
					obb.center.y = (root.y + ((tMat.col1.y * centerX) + (tMat.col2.y * centerY)));
					obb.extents.x = (0.5 * (upperX - lowerX));
					obb.extents.y = (0.5 * (upperY - lowerY));
				};
				i++;
			};
		}

	}
}//package Box2D.Collision.Shapes 
Section 10
//b2Shape (Box2D.Collision.Shapes.b2Shape)
package Box2D.Collision.Shapes {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;

	public class b2Shape {

		public var m_next:b2Shape;
		public var m_type:int;
		public var m_sweepRadius:Number;
		public var m_density:Number;
		public var m_filter:b2FilterData;
		public var m_friction:Number;
		public var m_isSensor:Boolean;
		public var m_restitution:Number;
		public var m_userData;
		public var m_proxyId:uint;
		public var m_body:b2Body;

		public static const e_polygonShape:int = 1;
		public static const e_concaveArcShape:int = 5;
		public static const e_convexArcShape:int = 4;
		public static const e_unknownShape:int = -1;
		public static const e_meshShape:int = 3;
		public static const e_circleShape:int = 0;
		public static const e_shapeTypeCount:int = 7;
		public static const e_staticEdgeShape:int = 6;

		private static var s_resetAABB:b2AABB = new b2AABB();
		private static var s_syncAABB:b2AABB = new b2AABB();
		private static var s_proxyAABB:b2AABB = new b2AABB();

		public function b2Shape(def:b2ShapeDef){
			super();
			m_userData = def.userData;
			m_friction = def.friction;
			m_restitution = def.restitution;
			m_density = def.density;
			m_body = null;
			m_sweepRadius = 0;
			m_next = null;
			m_proxyId = b2Pair.b2_nullProxy;
			m_filter = def.filter.Copy();
			m_isSensor = def.isSensor;
		}
		public function SetUserData(data):void{
			m_userData = data;
		}
		public function GetSweepRadius():Number{
			return (m_sweepRadius);
		}
		public function GetNext():b2Shape{
			return (m_next);
		}
		public function ComputeSweptAABB(aabb:b2AABB, xf1:b2XForm, xf2:b2XForm):void{
		}
		public function GetType():int{
			return (m_type);
		}
		public function GetRestitution():Number{
			return (m_restitution);
		}
		public function GetFriction():Number{
			return (m_friction);
		}
		public function GetFilterData():b2FilterData{
			return (m_filter.Copy());
		}
		public function TestSegment(xf:b2XForm, lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			return (false);
		}
		public function RefilterProxy(broadPhase:b2BroadPhase, transform:b2XForm):void{
			if (m_proxyId == b2Pair.b2_nullProxy){
				return;
			};
			broadPhase.DestroyProxy(m_proxyId);
			var aabb:b2AABB = s_resetAABB;
			ComputeAABB(aabb, transform);
			var inRange:Boolean = broadPhase.InRange(aabb);
			if (inRange){
				m_proxyId = broadPhase.CreateProxy(aabb, this);
			} else {
				m_proxyId = b2Pair.b2_nullProxy;
			};
		}
		public function SetFilterData(filter:b2FilterData):void{
			m_filter = filter.Copy();
		}
		public function GetUserData(){
			return (m_userData);
		}
		public function Synchronize(broadPhase:b2BroadPhase, transform1:b2XForm, transform2:b2XForm):Boolean{
			if (m_proxyId == b2Pair.b2_nullProxy){
				return (false);
			};
			var aabb:b2AABB = s_syncAABB;
			ComputeSweptAABB(aabb, transform1, transform2);
			if (broadPhase.InRange(aabb)){
				broadPhase.MoveProxy(m_proxyId, aabb);
				return (true);
			};
			return (false);
		}
		public function ComputeMass(massData:b2MassData):void{
		}
		public function IsSensor():Boolean{
			return (m_isSensor);
		}
		public function DestroyProxy(broadPhase:b2BroadPhase):void{
			if (m_proxyId != b2Pair.b2_nullProxy){
				broadPhase.DestroyProxy(m_proxyId);
				m_proxyId = b2Pair.b2_nullProxy;
			};
		}
		public function UpdateSweepRadius(center:b2Vec2):void{
		}
		public function ComputeAABB(aabb:b2AABB, xf:b2XForm):void{
		}
		public function GetBody():b2Body{
			return (m_body);
		}
		public function CreateProxy(broadPhase:b2BroadPhase, transform:b2XForm):void{
			var aabb:b2AABB = s_proxyAABB;
			ComputeAABB(aabb, transform);
			var inRange:Boolean = broadPhase.InRange(aabb);
			if (inRange){
				m_proxyId = broadPhase.CreateProxy(aabb, this);
			} else {
				m_proxyId = b2Pair.b2_nullProxy;
			};
		}
		public function TestPoint(xf:b2XForm, p:b2Vec2):Boolean{
			return (false);
		}

		public static function Destroy(shape:b2Shape, allocator):void{
		}
		public static function Create(def:b2ShapeDef, allocator):b2Shape{
			switch (def.type){
				case e_circleShape:
					return (new b2CircleShape(def));
				case e_polygonShape:
					return (new b2PolygonShape(def));
				case e_convexArcShape:
					return (new b2ConvexArcShape(def));
				case e_concaveArcShape:
					return (new b2ConcaveArcShape(def));
				default:
					throw (new Error("Shape type not found or cannot be added to Dynamic Bodies."));
			};
		}

	}
}//package Box2D.Collision.Shapes 
Section 11
//b2ShapeDef (Box2D.Collision.Shapes.b2ShapeDef)
package Box2D.Collision.Shapes {

	public class b2ShapeDef {

		public var friction:Number;// = 0.2
		public var isSensor:Boolean;// = false
		public var density:Number;// = 0
		public var restitution:Number;// = 0
		public var userData;// = null
		public var filter:b2FilterData;
		public var type:int;

		public function b2ShapeDef(){
			type = b2Shape.e_unknownShape;
			filter = new b2FilterData();
			super();
		}
	}
}//package Box2D.Collision.Shapes 
Section 12
//b2StaticEdgeChain (Box2D.Collision.Shapes.b2StaticEdgeChain)
package Box2D.Collision.Shapes {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2StaticEdgeChain {

		public var isALoop:Boolean;
		public var edges:Array;

		public function b2StaticEdgeChain(def:b2ShapeDef, world:b2World){
			var i:int;
			var v1:b2Vec2;
			var v2:b2Vec2;
			var s2:b2StaticEdgeShape;
			var angle:Number;
			var angle2:Number;
			var s:b2StaticEdgeShape;
			var core:b2Vec2;
			var cornerDir:b2Vec2;
			edges = new Array();
			super();
			var edgeDef:b2StaticEdgeChainDef = (def as b2StaticEdgeChainDef);
			isALoop = edgeDef.isALoop;
			if (edgeDef.isALoop){
				i = 0;
				v1 = edgeDef.vertices[(edgeDef.vertexCount - 1)];
			} else {
				i = 1;
				v1 = edgeDef.vertices[0];
			};
			v1 = v1.Copy();
			while (i < edgeDef.vertexCount) {
				v2 = edgeDef.vertices[i];
				v2 = v2.Copy();
				s = new b2StaticEdgeShape(v1, v2, edgeDef);
				edges.push(s);
				s.m_chain = this;
				s.m_next = world.m_groundBody.m_shapeList;
				world.m_groundBody.m_shapeList = s;
				world.m_groundBody.m_shapeCount++;
				s.m_body = world.m_groundBody;
				s.CreateProxy(world.m_broadPhase, world.m_groundBody.m_xf);
				s.UpdateSweepRadius(world.m_groundBody.m_sweep.localCenter);
				v1 = v2;
				i++;
			};
			if (edgeDef.isALoop){
				s = edges[(edgeDef.vertexCount - 1)];
				i = 0;
			} else {
				s = edges[0];
				i = 1;
			};
			angle = Math.atan2(s.m_direction.y, s.m_direction.x);
			while (i < edges.length) {
				s2 = edges[i];
				angle2 = Math.atan2(s2.m_direction.y, s2.m_direction.x);
				core = s2.m_direction.Copy();
				core.Multiply(Math.tan(((angle2 - angle) * 0.5)));
				core.Subtract(s2.m_normal);
				core.Multiply(b2Settings.b2_toiSlop);
				core.Add(s2.m_v1);
				cornerDir = s.m_direction.Copy();
				cornerDir.Add(s2.m_direction);
				cornerDir.Normalize();
				s.SetNextEdge(s2, core, cornerDir);
				s2.SetPrevEdge(s, core, cornerDir);
				s = s2;
				angle = angle2;
				i++;
			};
		}
	}
}//package Box2D.Collision.Shapes 
Section 13
//b2StaticEdgeChainDef (Box2D.Collision.Shapes.b2StaticEdgeChainDef)
package Box2D.Collision.Shapes {

	public class b2StaticEdgeChainDef extends b2ShapeDef {

		public var vertices:Array;
		public var vertexCount:int;
		public var isALoop:Boolean;

		public function b2StaticEdgeChainDef(){
			vertices = new Array();
			super();
			type = b2Shape.e_staticEdgeShape;
			isALoop = true;
			vertexCount = 0;
		}
	}
}//package Box2D.Collision.Shapes 
Section 14
//b2StaticEdgeShape (Box2D.Collision.Shapes.b2StaticEdgeShape)
package Box2D.Collision.Shapes {
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2StaticEdgeShape extends b2Shape {

		public var m_normal:b2Vec2;
		public var m_cornerDir1:b2Vec2;
		public var m_v1:b2Vec2;
		public var m_coreV1:b2Vec2;
		public var m_coreV2:b2Vec2;
		public var m_v2:b2Vec2;
		public var m_cornerDir2:b2Vec2;
		public var m_nextEdge:b2StaticEdgeShape;
		public var m_direction:b2Vec2;
		public var m_prevEdge:b2StaticEdgeShape;
		public var m_chain:b2StaticEdgeChain;
		public var m_length:Number;

		public function b2StaticEdgeShape(v1:b2Vec2, v2:b2Vec2, edgeDef:b2StaticEdgeChainDef){
			super(edgeDef);
			m_type = e_staticEdgeShape;
			m_v1 = v1;
			m_v2 = v2;
			m_direction = m_v2.Copy();
			m_direction.Subtract(m_v1);
			m_length = m_direction.Normalize();
			m_normal = new b2Vec2(m_direction.y, -(m_direction.x));
			m_coreV1 = m_normal.Copy();
			m_coreV1.Subtract(m_direction);
			m_coreV1.Multiply(-(b2Settings.b2_toiSlop));
			m_coreV1.Add(m_v1);
			m_coreV2 = m_normal.Copy();
			m_coreV2.Add(m_direction);
			m_coreV2.Multiply(-(b2Settings.b2_toiSlop));
			m_coreV2.Add(m_v2);
			m_cornerDir1 = m_normal;
			m_cornerDir2 = m_normal.Copy();
			m_cornerDir2.Multiply(-1);
		}
		public function GetDirectionVector():b2Vec2{
			return (m_direction);
		}
		override public function ComputeSweptAABB(aabb:b2AABB, transform1:b2XForm, transform2:b2XForm):void{
			return (ComputeAABB(aabb, transform1));
		}
		public function GetFirstVertex(xf:b2XForm):b2Vec2{
			return (m_coreV1);
		}
		public function GetNormalVector():b2Vec2{
			return (m_normal);
		}
		override public function TestSegment(transform:b2XForm, lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			var bX:Number;
			var bY:Number;
			var a:Number;
			var mu2:Number;
			var nLen:Number;
			var k_slop:Number = (100 * Number.MIN_VALUE);
			var rX:Number = (segment.p2.x - segment.p1.x);
			var rY:Number = (segment.p2.y - segment.p1.y);
			var nX:Number = (m_v2.y - m_v1.y);
			var nY:Number = (m_v1.x - m_v2.x);
			var denom:Number = -(((rX * nX) + (rY * nY)));
			if (denom > k_slop){
				bX = (segment.p1.x - m_v1.x);
				bY = (segment.p1.y - m_v1.y);
				a = ((bX * nX) + (bY * nY));
				if ((((0 <= a)) && ((a <= (maxLambda * denom))))){
					mu2 = ((-(rX) * bY) + (rY * bX));
					if (((((-(k_slop) * denom) <= mu2)) && ((mu2 <= (denom * (1 + k_slop)))))){
						a = (a / denom);
						nLen = Math.sqrt(((nX * nX) + (nY * nY)));
						nX = (nX / nLen);
						nY = (nY / nLen);
						lambda[0] = a;
						normal.Set(nX, nY);
						return (true);
					};
				};
			};
			return (false);
		}
		public function GetParentChain():b2StaticEdgeChain{
			return (m_chain);
		}
		public function Support(xf:b2XForm, dX:Number, dY:Number):b2Vec2{
			return (((((m_coreV1.x * dX) + (m_coreV1.y * dY)) > ((m_coreV2.x * dX) + (m_coreV2.y * dY)))) ? m_coreV1 : m_coreV2);
		}
		public function SetPrevEdge(edge:b2StaticEdgeShape, core:b2Vec2, cornerDir:b2Vec2):void{
			m_prevEdge = edge;
			m_coreV1 = core;
			m_cornerDir1 = cornerDir;
		}
		override public function UpdateSweepRadius(center:b2Vec2):void{
			var dX:Number = (m_v1.x - center.x);
			var dY:Number = (m_v1.y - center.y);
			var d1:Number = ((dX * dX) + (dY * dY));
			dX = (m_v2.x - center.x);
			dY = (m_v2.y - center.y);
			var d2:Number = ((dX * dX) + (dY * dY));
			dX = Math.sqrt(((d1 > d2)) ? d1 : d2);
			m_sweepRadius = dX;
		}
		public function GetVertex1():b2Vec2{
			return (m_v1);
		}
		public function SetNextEdge(edge:b2StaticEdgeShape, core:b2Vec2, cornerDir:b2Vec2):void{
			m_nextEdge = edge;
			m_coreV2 = core;
			m_cornerDir2 = cornerDir;
		}
		public function GetLength():Number{
			return (m_length);
		}
		override public function ComputeAABB(aabb:b2AABB, transform:b2XForm):void{
			if (m_v1.x < m_v2.x){
				aabb.lowerBound.x = m_v1.x;
				aabb.upperBound.x = m_v2.x;
			} else {
				aabb.lowerBound.x = m_v2.x;
				aabb.upperBound.x = m_v1.x;
			};
			if (m_v1.y < m_v2.y){
				aabb.lowerBound.y = m_v1.y;
				aabb.upperBound.y = m_v2.y;
			} else {
				aabb.lowerBound.y = m_v2.y;
				aabb.upperBound.y = m_v1.y;
			};
		}
		public function GetVertex2():b2Vec2{
			return (m_v2);
		}

	}
}//package Box2D.Collision.Shapes 
Section 15
//b2AABB (Box2D.Collision.b2AABB)
package Box2D.Collision {
	import Box2D.Common.Math.*;

	public class b2AABB {

		public var upperBound:b2Vec2;
		public var lowerBound:b2Vec2;

		public function b2AABB(){
			lowerBound = new b2Vec2();
			upperBound = new b2Vec2();
			super();
		}
		public function IsValid():Boolean{
			var dX:Number = (upperBound.x - lowerBound.x);
			var dY:Number = (upperBound.y - lowerBound.y);
			var valid:Boolean = (((dX >= 0)) && ((dY >= 0)));
			valid = ((((valid) && (lowerBound.IsValid()))) && (upperBound.IsValid()));
			return (valid);
		}

	}
}//package Box2D.Collision 
Section 16
//b2Bound (Box2D.Collision.b2Bound)
package Box2D.Collision {

	public class b2Bound {

		public var value:uint;
		public var proxyId:uint;
		public var stabbingCount:uint;

		public function b2Bound(){
			super();
		}
		public function Swap(b:b2Bound):void{
			var tempValue:uint = value;
			var tempProxyId:uint = proxyId;
			var tempStabbingCount:uint = stabbingCount;
			value = b.value;
			proxyId = b.proxyId;
			stabbingCount = b.stabbingCount;
			b.value = tempValue;
			b.proxyId = tempProxyId;
			b.stabbingCount = tempStabbingCount;
		}
		public function IsLower():Boolean{
			return (((value & 1) == 0));
		}
		public function IsUpper():Boolean{
			return (((value & 1) == 1));
		}

	}
}//package Box2D.Collision 
Section 17
//b2BoundValues (Box2D.Collision.b2BoundValues)
package Box2D.Collision {

	public class b2BoundValues {

		public var lowerValues:Array;
		public var upperValues:Array;

		public function b2BoundValues(){
			lowerValues = [0, 0];
			upperValues = [0, 0];
			super();
		}
	}
}//package Box2D.Collision 
Section 18
//b2BroadPhase (Box2D.Collision.b2BroadPhase)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2BroadPhase {

		public var m_bounds:Array;
		public var m_quantizationFactor:b2Vec2;
		public var m_worldAABB:b2AABB;
		public var m_freeProxy:uint;
		public var m_proxyCount:int;
		public var m_proxyPool:Array;
		public var m_queryResultCount:int;
		public var m_pairManager:b2PairManager;
		public var m_timeStamp:uint;
		public var m_queryResults:Array;

		public static const b2_nullEdge:uint = 0xFFFF;
		public static const b2_invalid:uint = 0xFFFF;

		public static var s_validate:Boolean = false;

		public function b2BroadPhase(worldAABB:b2AABB, callback:b2PairCallback){
			var i:int;
			var dY:Number;
			var tProxy:b2Proxy;
			var j:int;
			m_pairManager = new b2PairManager();
			m_proxyPool = new Array(b2Settings.b2_maxPairs);
			m_bounds = new Array((2 * b2Settings.b2_maxProxies));
			m_queryResults = new Array(b2Settings.b2_maxProxies);
			m_quantizationFactor = new b2Vec2();
			super();
			m_pairManager.Initialize(this, callback);
			m_worldAABB = worldAABB;
			m_proxyCount = 0;
			i = 0;
			while (i < b2Settings.b2_maxProxies) {
				m_queryResults[i] = 0;
				i++;
			};
			m_bounds = new Array(2);
			i = 0;
			while (i < 2) {
				m_bounds[i] = new Array((2 * b2Settings.b2_maxProxies));
				j = 0;
				while (j < (2 * b2Settings.b2_maxProxies)) {
					m_bounds[i][j] = new b2Bound();
					j++;
				};
				i++;
			};
			var dX:Number = (worldAABB.upperBound.x - worldAABB.lowerBound.x);
			dY = (worldAABB.upperBound.y - worldAABB.lowerBound.y);
			m_quantizationFactor.x = (b2Settings.USHRT_MAX / dX);
			m_quantizationFactor.y = (b2Settings.USHRT_MAX / dY);
			i = 0;
			while (i < (b2Settings.b2_maxProxies - 1)) {
				tProxy = new b2Proxy();
				m_proxyPool[i] = tProxy;
				tProxy.SetNext((i + 1));
				tProxy.timeStamp = 0;
				tProxy.overlapCount = b2_invalid;
				tProxy.userData = null;
				i++;
			};
			tProxy = new b2Proxy();
			m_proxyPool[int((b2Settings.b2_maxProxies - 1))] = tProxy;
			tProxy.SetNext(b2Pair.b2_nullProxy);
			tProxy.timeStamp = 0;
			tProxy.overlapCount = b2_invalid;
			tProxy.userData = null;
			m_freeProxy = 0;
			m_timeStamp = 1;
			m_queryResultCount = 0;
		}
		public function QueryAABB(aabb:b2AABB, userData, maxCount:int):int{
			var lowerIndex:uint;
			var upperIndex:uint;
			var proxy:b2Proxy;
			var lowerValues:Array = new Array();
			var upperValues:Array = new Array();
			ComputeBounds(lowerValues, upperValues, aabb);
			var lowerIndexOut:Array = [lowerIndex];
			var upperIndexOut:Array = [upperIndex];
			Query(lowerIndexOut, upperIndexOut, lowerValues[0], upperValues[0], m_bounds[0], (2 * m_proxyCount), 0);
			Query(lowerIndexOut, upperIndexOut, lowerValues[1], upperValues[1], m_bounds[1], (2 * m_proxyCount), 1);
			var count:int;
			var i:int;
			while ((((i < m_queryResultCount)) && ((count < maxCount)))) {
				proxy = m_proxyPool[m_queryResults[i]];
				userData[i] = proxy.userData;
				i++;
				count++;
			};
			m_queryResultCount = 0;
			IncrementTimeStamp();
			return (count);
		}
		public function Commit():void{
			m_pairManager.Commit();
		}
		public function GetProxy(proxyId:int):b2Proxy{
			var proxy:b2Proxy = m_proxyPool[proxyId];
			if ((((proxyId == b2Pair.b2_nullProxy)) || ((proxy.IsValid() == false)))){
				return (null);
			};
			return (proxy);
		}
		private function IncrementTimeStamp():void{
			var i:uint;
			if (m_timeStamp == b2Settings.USHRT_MAX){
				i = 0;
				while (i < b2Settings.b2_maxProxies) {
					(m_proxyPool[i] as b2Proxy).timeStamp = 0;
					i++;
				};
				m_timeStamp = 1;
			} else {
				m_timeStamp++;
			};
		}
		private function Query(lowerQueryOut:Array, upperQueryOut:Array, lowerValue:uint, upperValue:uint, bounds:Array, boundCount:uint, axis:int):void{
			var bound:b2Bound;
			var i:int;
			var s:int;
			var proxy:b2Proxy;
			var lowerQuery:uint = BinarySearch(bounds, boundCount, lowerValue);
			var upperQuery:uint = BinarySearch(bounds, boundCount, upperValue);
			var j:uint = lowerQuery;
			while (j < upperQuery) {
				bound = bounds[j];
				if (bound.IsLower()){
					IncrementOverlapCount(bound.proxyId);
				};
				j++;
			};
			if (lowerQuery > 0){
				i = (lowerQuery - 1);
				bound = bounds[i];
				s = bound.stabbingCount;
				while (s) {
					bound = bounds[i];
					if (bound.IsLower()){
						proxy = m_proxyPool[bound.proxyId];
						if (lowerQuery <= proxy.upperBounds[axis]){
							IncrementOverlapCount(bound.proxyId);
							s--;
						};
					};
					i--;
				};
			};
			lowerQueryOut[0] = lowerQuery;
			upperQueryOut[0] = upperQuery;
		}
		private function TestOverlapValidate(p1:b2Proxy, p2:b2Proxy):Boolean{
			var bounds:Array;
			var bound1:b2Bound;
			var bound2:b2Bound;
			var axis:int;
			while (axis < 2) {
				bounds = m_bounds[axis];
				bound1 = bounds[p1.lowerBounds[axis]];
				bound2 = bounds[p2.upperBounds[axis]];
				if (bound1.value > bound2.value){
					return (false);
				};
				bound1 = bounds[p1.upperBounds[axis]];
				bound2 = bounds[p2.lowerBounds[axis]];
				if (bound1.value < bound2.value){
					return (false);
				};
				axis++;
			};
			return (true);
		}
		private function ComputeBounds(lowerValues:Array, upperValues:Array, aabb:b2AABB):void{
			var minVertexX:Number = aabb.lowerBound.x;
			var minVertexY:Number = aabb.lowerBound.y;
			minVertexX = b2Math.b2Min(minVertexX, m_worldAABB.upperBound.x);
			minVertexY = b2Math.b2Min(minVertexY, m_worldAABB.upperBound.y);
			minVertexX = b2Math.b2Max(minVertexX, m_worldAABB.lowerBound.x);
			minVertexY = b2Math.b2Max(minVertexY, m_worldAABB.lowerBound.y);
			var maxVertexX:Number = aabb.upperBound.x;
			var maxVertexY:Number = aabb.upperBound.y;
			maxVertexX = b2Math.b2Min(maxVertexX, m_worldAABB.upperBound.x);
			maxVertexY = b2Math.b2Min(maxVertexY, m_worldAABB.upperBound.y);
			maxVertexX = b2Math.b2Max(maxVertexX, m_worldAABB.lowerBound.x);
			maxVertexY = b2Math.b2Max(maxVertexY, m_worldAABB.lowerBound.y);
			lowerValues[0] = (uint((m_quantizationFactor.x * (minVertexX - m_worldAABB.lowerBound.x))) & (b2Settings.USHRT_MAX - 1));
			upperValues[0] = ((uint((m_quantizationFactor.x * (maxVertexX - m_worldAABB.lowerBound.x))) & 0xFFFF) | 1);
			lowerValues[1] = (uint((m_quantizationFactor.y * (minVertexY - m_worldAABB.lowerBound.y))) & (b2Settings.USHRT_MAX - 1));
			upperValues[1] = ((uint((m_quantizationFactor.y * (maxVertexY - m_worldAABB.lowerBound.y))) & 0xFFFF) | 1);
		}
		public function CreateProxy(aabb:b2AABB, userData):uint{
			var index:uint;
			var proxy:b2Proxy;
			var bounds:Array;
			var lowerIndex:uint;
			var upperIndex:uint;
			var lowerIndexOut:Array;
			var upperIndexOut:Array;
			var tArr:Array;
			var j:int;
			var tEnd:int;
			var tBound1:b2Bound;
			var tBound2:b2Bound;
			var tBoundAS3:b2Bound;
			var tIndex:int;
			var proxy2:b2Proxy;
			var proxyId:uint = m_freeProxy;
			proxy = m_proxyPool[proxyId];
			m_freeProxy = proxy.GetNext();
			proxy.overlapCount = 0;
			proxy.userData = userData;
			var boundCount:uint = (2 * m_proxyCount);
			var lowerValues:Array = new Array();
			var upperValues:Array = new Array();
			ComputeBounds(lowerValues, upperValues, aabb);
			var axis:int;
			while (axis < 2) {
				bounds = m_bounds[axis];
				lowerIndexOut = [lowerIndex];
				upperIndexOut = [upperIndex];
				Query(lowerIndexOut, upperIndexOut, lowerValues[axis], upperValues[axis], bounds, boundCount, axis);
				lowerIndex = lowerIndexOut[0];
				upperIndex = upperIndexOut[0];
				tArr = new Array();
				tEnd = (boundCount - upperIndex);
				j = 0;
				while (j < tEnd) {
					tArr[j] = new b2Bound();
					tBound1 = tArr[j];
					tBound2 = bounds[int((upperIndex + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tEnd = tArr.length;
				tIndex = (upperIndex + 2);
				j = 0;
				while (j < tEnd) {
					tBound2 = tArr[j];
					tBound1 = bounds[int((tIndex + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tArr = new Array();
				tEnd = (upperIndex - lowerIndex);
				j = 0;
				while (j < tEnd) {
					tArr[j] = new b2Bound();
					tBound1 = tArr[j];
					tBound2 = bounds[int((lowerIndex + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tEnd = tArr.length;
				tIndex = (lowerIndex + 1);
				j = 0;
				while (j < tEnd) {
					tBound2 = tArr[j];
					tBound1 = bounds[int((tIndex + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				upperIndex++;
				tBound1 = bounds[lowerIndex];
				tBound2 = bounds[upperIndex];
				tBound1.value = lowerValues[axis];
				tBound1.proxyId = proxyId;
				tBound2.value = upperValues[axis];
				tBound2.proxyId = proxyId;
				tBoundAS3 = bounds[int((lowerIndex - 1))];
				tBound1.stabbingCount = ((lowerIndex == 0)) ? 0 : tBoundAS3.stabbingCount;
				tBoundAS3 = bounds[int((upperIndex - 1))];
				tBound2.stabbingCount = tBoundAS3.stabbingCount;
				index = lowerIndex;
				while (index < upperIndex) {
					tBoundAS3 = bounds[index];
					tBoundAS3.stabbingCount++;
					index++;
				};
				index = lowerIndex;
				while (index < (boundCount + 2)) {
					tBound1 = bounds[index];
					proxy2 = m_proxyPool[tBound1.proxyId];
					if (tBound1.IsLower()){
						proxy2.lowerBounds[axis] = index;
					} else {
						proxy2.upperBounds[axis] = index;
					};
					index++;
				};
				axis++;
			};
			m_proxyCount++;
			var i:int;
			while (i < m_queryResultCount) {
				m_pairManager.AddBufferedPair(proxyId, m_queryResults[i]);
				i++;
			};
			m_pairManager.Commit();
			m_queryResultCount = 0;
			IncrementTimeStamp();
			return (proxyId);
		}
		public function DestroyProxy(proxyId:uint):void{
			var tBound1:b2Bound;
			var tBound2:b2Bound;
			var bounds:Array;
			var lowerIndex:uint;
			var upperIndex:uint;
			var lowerValue:uint;
			var upperValue:uint;
			var tArr:Array;
			var j:int;
			var tEnd:int;
			var tIndex:int;
			var index:uint;
			var index2:int;
			var proxy2:b2Proxy;
			var proxy:b2Proxy = m_proxyPool[proxyId];
			var boundCount:int = (2 * m_proxyCount);
			var axis:int;
			while (axis < 2) {
				bounds = m_bounds[axis];
				lowerIndex = proxy.lowerBounds[axis];
				upperIndex = proxy.upperBounds[axis];
				tBound1 = bounds[lowerIndex];
				lowerValue = tBound1.value;
				tBound2 = bounds[upperIndex];
				upperValue = tBound2.value;
				tArr = new Array();
				tEnd = ((upperIndex - lowerIndex) - 1);
				j = 0;
				while (j < tEnd) {
					tArr[j] = new b2Bound();
					tBound1 = tArr[j];
					tBound2 = bounds[int(((lowerIndex + 1) + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tEnd = tArr.length;
				tIndex = lowerIndex;
				j = 0;
				while (j < tEnd) {
					tBound2 = tArr[j];
					tBound1 = bounds[int((tIndex + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tArr = new Array();
				tEnd = ((boundCount - upperIndex) - 1);
				j = 0;
				while (j < tEnd) {
					tArr[j] = new b2Bound();
					tBound1 = tArr[j];
					tBound2 = bounds[int(((upperIndex + 1) + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tEnd = tArr.length;
				tIndex = (upperIndex - 1);
				j = 0;
				while (j < tEnd) {
					tBound2 = tArr[j];
					tBound1 = bounds[int((tIndex + j))];
					tBound1.value = tBound2.value;
					tBound1.proxyId = tBound2.proxyId;
					tBound1.stabbingCount = tBound2.stabbingCount;
					j++;
				};
				tEnd = (boundCount - 2);
				index = lowerIndex;
				while (index < tEnd) {
					tBound1 = bounds[index];
					proxy2 = m_proxyPool[tBound1.proxyId];
					if (tBound1.IsLower()){
						proxy2.lowerBounds[axis] = index;
					} else {
						proxy2.upperBounds[axis] = index;
					};
					index++;
				};
				tEnd = (upperIndex - 1);
				index2 = lowerIndex;
				while (index2 < tEnd) {
					tBound1 = bounds[index2];
					tBound1.stabbingCount--;
					index2++;
				};
				Query([0], [0], lowerValue, upperValue, bounds, (boundCount - 2), axis);
				axis++;
			};
			var i:int;
			while (i < m_queryResultCount) {
				m_pairManager.RemoveBufferedPair(proxyId, m_queryResults[i]);
				i++;
			};
			m_pairManager.Commit();
			m_queryResultCount = 0;
			IncrementTimeStamp();
			proxy.userData = null;
			proxy.overlapCount = b2_invalid;
			proxy.lowerBounds[0] = b2_invalid;
			proxy.lowerBounds[1] = b2_invalid;
			proxy.upperBounds[0] = b2_invalid;
			proxy.upperBounds[1] = b2_invalid;
			proxy.SetNext(m_freeProxy);
			m_freeProxy = proxyId;
			m_proxyCount--;
		}
		public function TestOverlap(b:b2BoundValues, p:b2Proxy):Boolean{
			var bounds:Array;
			var bound:b2Bound;
			var axis:int;
			while (axis < 2) {
				bounds = m_bounds[axis];
				bound = bounds[p.upperBounds[axis]];
				if (b.lowerValues[axis] > bound.value){
					return (false);
				};
				bound = bounds[p.lowerBounds[axis]];
				if (b.upperValues[axis] < bound.value){
					return (false);
				};
				axis++;
			};
			return (true);
		}
		public function Validate():void{
			var pair:b2Pair;
			var proxy1:b2Proxy;
			var proxy2:b2Proxy;
			var overlap:Boolean;
			var bounds:b2Bound;
			var boundCount:uint;
			var stabbingCount:uint;
			var i:uint;
			var bound:b2Bound;
			var axis:int;
			while (axis < 2) {
				bounds = m_bounds[axis];
				boundCount = (2 * m_proxyCount);
				stabbingCount = 0;
				i = 0;
				while (i < boundCount) {
					bound = bounds[i];
					if (bound.IsLower() == true){
						stabbingCount++;
					} else {
						stabbingCount--;
					};
					i++;
				};
				axis++;
			};
		}
		private function IncrementOverlapCount(proxyId:uint):void{
			var proxy:b2Proxy = m_proxyPool[proxyId];
			if (proxy.timeStamp < m_timeStamp){
				proxy.timeStamp = m_timeStamp;
				proxy.overlapCount = 1;
			} else {
				proxy.overlapCount = 2;
				m_queryResults[m_queryResultCount] = proxyId;
				m_queryResultCount++;
			};
		}
		public function InRange(aabb:b2AABB):Boolean{
			var dX:Number;
			var dY:Number;
			var d2X:Number;
			var d2Y:Number;
			dX = aabb.lowerBound.x;
			dY = aabb.lowerBound.y;
			dX = (dX - m_worldAABB.upperBound.x);
			dY = (dY - m_worldAABB.upperBound.y);
			d2X = m_worldAABB.lowerBound.x;
			d2Y = m_worldAABB.lowerBound.y;
			d2X = (d2X - aabb.upperBound.x);
			d2Y = (d2Y - aabb.upperBound.y);
			dX = b2Math.b2Max(dX, d2X);
			dY = b2Math.b2Max(dY, d2Y);
			return ((b2Math.b2Max(dX, dY) < 0));
		}
		public function MoveProxy(proxyId:uint, aabb:b2AABB):void{
			var as3arr:Array;
			var as3int:int;
			var axis:uint;
			var index:uint;
			var bound:b2Bound;
			var prevBound:b2Bound;
			var nextBound:b2Bound;
			var nextProxyId:uint;
			var nextProxy:b2Proxy;
			var bounds:Array;
			var lowerIndex:uint;
			var upperIndex:uint;
			var lowerValue:uint;
			var upperValue:uint;
			var deltaLower:int;
			var deltaUpper:int;
			var prevProxyId:uint;
			var prevProxy:b2Proxy;
			if ((((proxyId == b2Pair.b2_nullProxy)) || ((b2Settings.b2_maxProxies <= proxyId)))){
				return;
			};
			if (aabb.IsValid() == false){
				return;
			};
			var boundCount:uint = (2 * m_proxyCount);
			var proxy:b2Proxy = m_proxyPool[proxyId];
			var newValues:b2BoundValues = new b2BoundValues();
			ComputeBounds(newValues.lowerValues, newValues.upperValues, aabb);
			var oldValues:b2BoundValues = new b2BoundValues();
			axis = 0;
			while (axis < 2) {
				bound = m_bounds[axis][proxy.lowerBounds[axis]];
				oldValues.lowerValues[axis] = bound.value;
				bound = m_bounds[axis][proxy.upperBounds[axis]];
				oldValues.upperValues[axis] = bound.value;
				axis++;
			};
			axis = 0;
			while (axis < 2) {
				bounds = m_bounds[axis];
				lowerIndex = proxy.lowerBounds[axis];
				upperIndex = proxy.upperBounds[axis];
				lowerValue = newValues.lowerValues[axis];
				upperValue = newValues.upperValues[axis];
				bound = bounds[lowerIndex];
				deltaLower = (lowerValue - bound.value);
				bound.value = lowerValue;
				bound = bounds[upperIndex];
				deltaUpper = (upperValue - bound.value);
				bound.value = upperValue;
				if (deltaLower < 0){
					index = lowerIndex;
					while ((((index > 0)) && ((lowerValue < (bounds[int((index - 1))] as b2Bound).value)))) {
						bound = bounds[index];
						prevBound = bounds[int((index - 1))];
						prevProxyId = prevBound.proxyId;
						prevProxy = m_proxyPool[prevBound.proxyId];
						prevBound.stabbingCount++;
						if (prevBound.IsUpper() == true){
							if (TestOverlap(newValues, prevProxy)){
								m_pairManager.AddBufferedPair(proxyId, prevProxyId);
							};
							as3arr = prevProxy.upperBounds;
							as3int = as3arr[axis];
							as3int++;
							as3arr[axis] = as3int;
							bound.stabbingCount++;
						} else {
							as3arr = prevProxy.lowerBounds;
							as3int = as3arr[axis];
							as3int++;
							as3arr[axis] = as3int;
							bound.stabbingCount--;
						};
						as3arr = proxy.lowerBounds;
						as3int = as3arr[axis];
						as3int--;
						as3arr[axis] = as3int;
						bound.Swap(prevBound);
						index--;
					};
				};
				if (deltaUpper > 0){
					index = upperIndex;
					while ((((index < (boundCount - 1))) && (((bounds[int((index + 1))] as b2Bound).value <= upperValue)))) {
						bound = bounds[index];
						nextBound = bounds[int((index + 1))];
						nextProxyId = nextBound.proxyId;
						nextProxy = m_proxyPool[nextProxyId];
						nextBound.stabbingCount++;
						if (nextBound.IsLower() == true){
							if (TestOverlap(newValues, nextProxy)){
								m_pairManager.AddBufferedPair(proxyId, nextProxyId);
							};
							as3arr = nextProxy.lowerBounds;
							as3int = as3arr[axis];
							as3int--;
							as3arr[axis] = as3int;
							bound.stabbingCount++;
						} else {
							as3arr = nextProxy.upperBounds;
							as3int = as3arr[axis];
							as3int--;
							as3arr[axis] = as3int;
							bound.stabbingCount--;
						};
						as3arr = proxy.upperBounds;
						as3int = as3arr[axis];
						as3int++;
						as3arr[axis] = as3int;
						bound.Swap(nextBound);
						index++;
					};
				};
				if (deltaLower > 0){
					index = lowerIndex;
					while ((((index < (boundCount - 1))) && (((bounds[int((index + 1))] as b2Bound).value <= lowerValue)))) {
						bound = bounds[index];
						nextBound = bounds[int((index + 1))];
						nextProxyId = nextBound.proxyId;
						nextProxy = m_proxyPool[nextProxyId];
						nextBound.stabbingCount--;
						if (nextBound.IsUpper()){
							if (TestOverlap(oldValues, nextProxy)){
								m_pairManager.RemoveBufferedPair(proxyId, nextProxyId);
							};
							as3arr = nextProxy.upperBounds;
							as3int = as3arr[axis];
							as3int--;
							as3arr[axis] = as3int;
							bound.stabbingCount--;
						} else {
							as3arr = nextProxy.lowerBounds;
							as3int = as3arr[axis];
							as3int--;
							as3arr[axis] = as3int;
							bound.stabbingCount++;
						};
						as3arr = proxy.lowerBounds;
						as3int = as3arr[axis];
						as3int++;
						as3arr[axis] = as3int;
						bound.Swap(nextBound);
						index++;
					};
				};
				if (deltaUpper < 0){
					index = upperIndex;
					while ((((index > 0)) && ((upperValue < (bounds[int((index - 1))] as b2Bound).value)))) {
						bound = bounds[index];
						prevBound = bounds[int((index - 1))];
						prevProxyId = prevBound.proxyId;
						prevProxy = m_proxyPool[prevProxyId];
						prevBound.stabbingCount--;
						if (prevBound.IsLower() == true){
							if (TestOverlap(oldValues, prevProxy)){
								m_pairManager.RemoveBufferedPair(proxyId, prevProxyId);
							};
							as3arr = prevProxy.lowerBounds;
							as3int = as3arr[axis];
							as3int++;
							as3arr[axis] = as3int;
							bound.stabbingCount--;
						} else {
							as3arr = prevProxy.upperBounds;
							as3int = as3arr[axis];
							as3int++;
							as3arr[axis] = as3int;
							bound.stabbingCount++;
						};
						as3arr = proxy.upperBounds;
						as3int = as3arr[axis];
						as3int--;
						as3arr[axis] = as3int;
						bound.Swap(prevBound);
						index--;
					};
				};
				axis++;
			};
		}

		public static function BinarySearch(bounds:Array, count:int, value:uint):uint{
			var mid:int;
			var bound:b2Bound;
			var low:int;
			var high:int = (count - 1);
			while (low <= high) {
				mid = ((low + high) / 2);
				bound = bounds[mid];
				if (bound.value > value){
					high = (mid - 1);
				} else {
					if (bound.value < value){
						low = (mid + 1);
					} else {
						return (uint(mid));
					};
				};
			};
			return (uint(low));
		}

	}
}//package Box2D.Collision 
Section 19
//b2BufferedPair (Box2D.Collision.b2BufferedPair)
package Box2D.Collision {

	public class b2BufferedPair {

		public var proxyId1:uint;
		public var proxyId2:uint;

		public function b2BufferedPair(){
			super();
		}
	}
}//package Box2D.Collision 
Section 20
//b2Collision (Box2D.Collision.b2Collision)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2Collision {

		public static const b2_nullFeature:uint = 0xFF;

		private static var b2CollidePolyTempVec:b2Vec2 = new b2Vec2();

		public function b2Collision(){
			super();
		}
		public static function EdgeSeparation(poly1:b2PolygonShape, xf1:b2XForm, edge1:int, poly2:b2PolygonShape, xf2:b2XForm):Number{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var dot:Number;
			var count1:int = poly1.m_vertexCount;
			var vertices1:Array = poly1.m_vertices;
			var normals1:Array = poly1.m_normals;
			var count2:int = poly2.m_vertexCount;
			var vertices2:Array = poly2.m_vertices;
			tMat = xf1.R;
			tVec = normals1[edge1];
			var normal1WorldX:Number = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			var normal1WorldY:Number = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			tMat = xf2.R;
			var normal1X:Number = ((tMat.col1.x * normal1WorldX) + (tMat.col1.y * normal1WorldY));
			var normal1Y:Number = ((tMat.col2.x * normal1WorldX) + (tMat.col2.y * normal1WorldY));
			var index:int;
			var minDot:Number = Number.MAX_VALUE;
			var i:int;
			while (i < count2) {
				tVec = vertices2[i];
				dot = ((tVec.x * normal1X) + (tVec.y * normal1Y));
				if (dot < minDot){
					minDot = dot;
					index = i;
				};
				i++;
			};
			tVec = vertices1[edge1];
			tMat = xf1.R;
			var v1X:Number = (xf1.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var v1Y:Number = (xf1.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tVec = vertices2[index];
			tMat = xf2.R;
			var v2X:Number = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var v2Y:Number = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			v2X = (v2X - v1X);
			v2Y = (v2Y - v1Y);
			var separation:Number = ((v2X * normal1WorldX) + (v2Y * normal1WorldY));
			return (separation);
		}
		public static function b2TestOverlap(a:b2AABB, b:b2AABB):Boolean{
			var t1:b2Vec2 = b.lowerBound;
			var t2:b2Vec2 = a.upperBound;
			var d1X:Number = (t1.x - t2.x);
			var d1Y:Number = (t1.y - t2.y);
			t1 = a.lowerBound;
			t2 = b.upperBound;
			var d2X:Number = (t1.x - t2.x);
			var d2Y:Number = (t1.y - t2.y);
			if ((((d1X > 0)) || ((d1Y > 0)))){
				return (false);
			};
			if ((((d2X > 0)) || ((d2Y > 0)))){
				return (false);
			};
			return (true);
		}
		public static function FindIncidentEdge(c:Array, poly1:b2PolygonShape, xf1:b2XForm, edge1:int, poly2:b2PolygonShape, xf2:b2XForm):void{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var tClip:ClipVertex;
			var dot:Number;
			var count1:int = poly1.m_vertexCount;
			var normals1:Array = poly1.m_normals;
			var count2:int = poly2.m_vertexCount;
			var vertices2:Array = poly2.m_vertices;
			var normals2:Array = poly2.m_normals;
			tMat = xf1.R;
			tVec = normals1[edge1];
			var normal1X:Number = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			var normal1Y:Number = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			tMat = xf2.R;
			var tX:Number = ((tMat.col1.x * normal1X) + (tMat.col1.y * normal1Y));
			normal1Y = ((tMat.col2.x * normal1X) + (tMat.col2.y * normal1Y));
			normal1X = tX;
			var index:int;
			var minDot:Number = Number.MAX_VALUE;
			var i:int;
			while (i < count2) {
				tVec = normals2[i];
				dot = ((normal1X * tVec.x) + (normal1Y * tVec.y));
				if (dot < minDot){
					minDot = dot;
					index = i;
				};
				i++;
			};
			var i1:int = index;
			var i2:int = (((i1 + 1) < count2)) ? (i1 + 1) : 0;
			tClip = c[0];
			tVec = vertices2[i1];
			tMat = xf2.R;
			tClip.v.x = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			tClip.v.y = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tClip.id.features.referenceEdge = edge1;
			tClip.id.features.incidentEdge = i1;
			tClip.id.features.incidentVertex = 0;
			tClip = c[1];
			tVec = vertices2[i2];
			tMat = xf2.R;
			tClip.v.x = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			tClip.v.y = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tClip.id.features.referenceEdge = edge1;
			tClip.id.features.incidentEdge = i2;
			tClip.id.features.incidentVertex = 1;
		}
		public static function b2CollidePolygons(manifold:b2Manifold, polyA:b2PolygonShape, xfA:b2XForm, polyB:b2PolygonShape, xfB:b2XForm):void{
			var cv:ClipVertex;
			var poly1:b2PolygonShape;
			var poly2:b2PolygonShape;
			var edge1:int;
			var flip:uint;
			var np:int;
			var v12:b2Vec2;
			var separation:Number;
			var cp:b2ManifoldPoint;
			manifold.pointCount = 0;
			var edgeA:int;
			var edgeAO:Array = [edgeA];
			var separationA:Number = FindMaxSeparation(edgeAO, polyA, xfA, polyB, xfB);
			edgeA = edgeAO[0];
			if (separationA > 0){
				return;
			};
			var edgeB:int;
			var edgeBO:Array = [edgeB];
			var separationB:Number = FindMaxSeparation(edgeBO, polyB, xfB, polyA, xfA);
			edgeB = edgeBO[0];
			if (separationB > 0){
				return;
			};
			var xf1:b2XForm = new b2XForm();
			var xf2:b2XForm = new b2XForm();
			var k_relativeTol:Number = 0.98;
			var k_absoluteTol:Number = 0.001;
			if (separationB > ((k_relativeTol * separationA) + k_absoluteTol)){
				poly1 = polyB;
				poly2 = polyA;
				xf1.Set(xfB);
				xf2.Set(xfA);
				edge1 = edgeB;
				flip = 1;
			} else {
				poly1 = polyA;
				poly2 = polyB;
				xf1.Set(xfA);
				xf2.Set(xfB);
				edge1 = edgeA;
				flip = 0;
			};
			var incidentEdge:Array = [new ClipVertex(), new ClipVertex()];
			FindIncidentEdge(incidentEdge, poly1, xf1, edge1, poly2, xf2);
			var count1:int = poly1.m_vertexCount;
			var vertices1:Array = poly1.m_vertices;
			var tVec:b2Vec2 = vertices1[edge1];
			var v11:b2Vec2 = tVec.Copy();
			if ((edge1 + 1) < count1){
				tVec = vertices1[int((edge1 + 1))];
				v12 = tVec.Copy();
			} else {
				tVec = vertices1[0];
				v12 = tVec.Copy();
			};
			var dv:b2Vec2 = b2Math.SubtractVV(v12, v11);
			var sideNormal:b2Vec2 = b2Math.b2MulMV(xf1.R, b2Math.SubtractVV(v12, v11));
			sideNormal.Normalize();
			var frontNormal:b2Vec2 = b2Math.b2CrossVF(sideNormal, 1);
			v11 = b2Math.b2MulX(xf1, v11);
			v12 = b2Math.b2MulX(xf1, v12);
			var frontOffset:Number = b2Math.b2Dot(frontNormal, v11);
			var sideOffset1:Number = -(b2Math.b2Dot(sideNormal, v11));
			var sideOffset2:Number = b2Math.b2Dot(sideNormal, v12);
			var clipPoints1:Array = [new ClipVertex(), new ClipVertex()];
			var clipPoints2:Array = [new ClipVertex(), new ClipVertex()];
			np = ClipSegmentToLine(clipPoints1, incidentEdge, sideNormal.Negative(), sideOffset1);
			if (np < 2){
				return;
			};
			np = ClipSegmentToLine(clipPoints2, clipPoints1, sideNormal, sideOffset2);
			if (np < 2){
				return;
			};
			manifold.normal = (flip) ? frontNormal.Negative() : frontNormal.Copy();
			var pointCount:int;
			var i:int;
			while (i < b2Settings.b2_maxManifoldPoints) {
				cv = clipPoints2[i];
				separation = (b2Math.b2Dot(frontNormal, cv.v) - frontOffset);
				if (separation <= 0){
					cp = manifold.points[pointCount];
					cp.separation = separation;
					cp.localPoint1 = b2Math.b2MulXT(xfA, cv.v);
					cp.localPoint2 = b2Math.b2MulXT(xfB, cv.v);
					cp.id.key = cv.id._key;
					cp.id.features.flip = flip;
					pointCount++;
				};
				i++;
			};
			manifold.pointCount = pointCount;
		}
		public static function FindMaxSeparation(edgeIndex:Array, poly1:b2PolygonShape, xf1:b2XForm, poly2:b2PolygonShape, xf2:b2XForm):Number{
			var tVec:b2Vec2;
			var tMat:b2Mat22;
			var bestEdge:int;
			var bestSeparation:Number;
			var increment:int;
			var dot:Number;
			var count1:int = poly1.m_vertexCount;
			var normals1:Array = poly1.m_normals;
			tMat = xf2.R;
			tVec = poly2.m_centroid;
			var dX:Number = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var dY:Number = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tMat = xf1.R;
			tVec = poly1.m_centroid;
			dX = (dX - (xf1.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y))));
			dY = (dY - (xf1.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y))));
			var dLocal1X:Number = ((dX * xf1.R.col1.x) + (dY * xf1.R.col1.y));
			var dLocal1Y:Number = ((dX * xf1.R.col2.x) + (dY * xf1.R.col2.y));
			var edge:int;
			var maxDot:Number = -(Number.MAX_VALUE);
			var i:int;
			while (i < count1) {
				tVec = normals1[i];
				dot = ((tVec.x * dLocal1X) + (tVec.y * dLocal1Y));
				if (dot > maxDot){
					maxDot = dot;
					edge = i;
				};
				i++;
			};
			var s:Number = EdgeSeparation(poly1, xf1, edge, poly2, xf2);
			if (s > 0){
				return (s);
			};
			var prevEdge:int = (((edge - 1) >= 0)) ? (edge - 1) : (count1 - 1);
			var sPrev:Number = EdgeSeparation(poly1, xf1, prevEdge, poly2, xf2);
			if (sPrev > 0){
				return (sPrev);
			};
			var nextEdge:int = (((edge + 1) < count1)) ? (edge + 1) : 0;
			var sNext:Number = EdgeSeparation(poly1, xf1, nextEdge, poly2, xf2);
			if (sNext > 0){
				return (sNext);
			};
			if ((((sPrev > s)) && ((sPrev > sNext)))){
				increment = -1;
				bestEdge = prevEdge;
				bestSeparation = sPrev;
			} else {
				if (sNext > s){
					increment = 1;
					bestEdge = nextEdge;
					bestSeparation = sNext;
				} else {
					edgeIndex[0] = edge;
					return (s);
				};
			};
			while (true) {
				if (increment == -1){
					edge = (((bestEdge - 1) >= 0)) ? (bestEdge - 1) : (count1 - 1);
				} else {
					edge = (((bestEdge + 1) < count1)) ? (bestEdge + 1) : 0;
				};
				s = EdgeSeparation(poly1, xf1, edge, poly2, xf2);
				if (s > 0){
					return (s);
				};
				if (s > bestSeparation){
					bestEdge = edge;
					bestSeparation = s;
				} else {
					break;
				};
			};
			edgeIndex[0] = bestEdge;
			return (bestSeparation);
		}
		public static function ClipSegmentToLine(vOut:Array, vIn:Array, normal:b2Vec2, offset:Number):int{
			var cv:ClipVertex;
			var numOut:int;
			var vIn0:b2Vec2;
			var vIn1:b2Vec2;
			var distance0:Number;
			var interp:Number;
			var tVec:b2Vec2;
			var cv2:ClipVertex;
			numOut = 0;
			cv = vIn[0];
			vIn0 = cv.v;
			cv = vIn[1];
			vIn1 = cv.v;
			distance0 = (b2Math.b2Dot(normal, vIn0) - offset);
			var distance1:Number = (b2Math.b2Dot(normal, vIn1) - offset);
			if (distance0 <= 0){
				var _temp1 = numOut;
				numOut = (numOut + 1);
				var _local14 = _temp1;
				vOut[_local14] = vIn[0];
			};
			if (distance1 <= 0){
				var _temp2 = numOut;
				numOut = (numOut + 1);
				_local14 = _temp2;
				vOut[_local14] = vIn[1];
			};
			if ((distance0 * distance1) < 0){
				interp = (distance0 / (distance0 - distance1));
				cv = vOut[numOut];
				tVec = cv.v;
				tVec.x = (vIn0.x + (interp * (vIn1.x - vIn0.x)));
				tVec.y = (vIn0.y + (interp * (vIn1.y - vIn0.y)));
				cv = vOut[numOut];
				if (distance0 > 0){
					cv2 = vIn[0];
					cv.id = cv2.id;
				} else {
					cv2 = vIn[1];
					cv.id = cv2.id;
				};
				numOut++;
			};
			return (numOut);
		}
		public static function b2CollideCircles(manifold:b2Manifold, circle1:b2CircleShape, xf1:b2XForm, circle2:b2CircleShape, xf2:b2XForm):void{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var separation:Number;
			var dist:Number;
			var a:Number;
			manifold.pointCount = 0;
			tMat = xf1.R;
			tVec = circle1.m_localPosition;
			var p1X:Number = (xf1.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var p1Y:Number = (xf1.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tMat = xf2.R;
			tVec = circle2.m_localPosition;
			var p2X:Number = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var p2Y:Number = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			var dX:Number = (p2X - p1X);
			var dY:Number = (p2Y - p1Y);
			var distSqr:Number = ((dX * dX) + (dY * dY));
			var r1:Number = circle1.m_radius;
			var r2:Number = circle2.m_radius;
			var radiusSum:Number = (r1 + r2);
			if (distSqr > (radiusSum * radiusSum)){
				return;
			};
			if (distSqr < Number.MIN_VALUE){
				separation = -(radiusSum);
				manifold.normal.Set(0, 1);
			} else {
				dist = Math.sqrt(distSqr);
				separation = (dist - radiusSum);
				a = (1 / dist);
				manifold.normal.x = (a * dX);
				manifold.normal.y = (a * dY);
			};
			manifold.pointCount = 1;
			var tPoint:b2ManifoldPoint = manifold.points[0];
			tPoint.id.key = 0;
			tPoint.separation = separation;
			p1X = (p1X + (r1 * manifold.normal.x));
			p1Y = (p1Y + (r1 * manifold.normal.y));
			p2X = (p2X - (r2 * manifold.normal.x));
			p2Y = (p2Y - (r2 * manifold.normal.y));
			var pX:Number = (0.5 * (p1X + p2X));
			var pY:Number = (0.5 * (p1Y + p2Y));
			var tX:Number = (pX - xf1.position.x);
			var tY:Number = (pY - xf1.position.y);
			tPoint.localPoint1.x = ((tX * xf1.R.col1.x) + (tY * xf1.R.col1.y));
			tPoint.localPoint1.y = ((tX * xf1.R.col2.x) + (tY * xf1.R.col2.y));
			tX = (pX - xf2.position.x);
			tY = (pY - xf2.position.y);
			tPoint.localPoint2.x = ((tX * xf2.R.col1.x) + (tY * xf2.R.col1.y));
			tPoint.localPoint2.y = ((tX * xf2.R.col2.x) + (tY * xf2.R.col2.y));
		}
		public static function b2CollidePolygonAndCircle(manifold:b2Manifold, polygon:b2PolygonShape, xf1:b2XForm, circle:b2CircleShape, xf2:b2XForm):void{
			var tPoint:b2ManifoldPoint;
			var dX:Number;
			var dY:Number;
			var positionX:Number;
			var positionY:Number;
			var tVec:b2Vec2;
			var tMat:b2Mat22;
			var dist:Number;
			var pX:Number;
			var pY:Number;
			var s:Number;
			manifold.pointCount = 0;
			tMat = xf2.R;
			tVec = circle.m_localPosition;
			var cX:Number = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var cY:Number = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			dX = (cX - xf1.position.x);
			dY = (cY - xf1.position.y);
			tMat = xf1.R;
			var cLocalX:Number = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			var cLocalY:Number = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			var normalIndex:int;
			var separation:Number = -(Number.MAX_VALUE);
			var radius:Number = circle.m_radius;
			var vertexCount:int = polygon.m_vertexCount;
			var vertices:Array = polygon.m_vertices;
			var normals:Array = polygon.m_normals;
			var i:int;
			while (i < vertexCount) {
				tVec = vertices[i];
				dX = (cLocalX - tVec.x);
				dY = (cLocalY - tVec.y);
				tVec = normals[i];
				s = ((tVec.x * dX) + (tVec.y * dY));
				if (s > radius){
					return;
				};
				if (s > separation){
					separation = s;
					normalIndex = i;
				};
				i++;
			};
			if (separation < Number.MIN_VALUE){
				manifold.pointCount = 1;
				tVec = normals[normalIndex];
				tMat = xf1.R;
				manifold.normal.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
				manifold.normal.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
				tPoint = manifold.points[0];
				tPoint.id.features.incidentEdge = normalIndex;
				tPoint.id.features.incidentVertex = b2_nullFeature;
				tPoint.id.features.referenceEdge = 0;
				tPoint.id.features.flip = 0;
				positionX = (cX - (radius * manifold.normal.x));
				positionY = (cY - (radius * manifold.normal.y));
				dX = (positionX - xf1.position.x);
				dY = (positionY - xf1.position.y);
				tMat = xf1.R;
				tPoint.localPoint1.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				tPoint.localPoint1.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				dX = (positionX - xf2.position.x);
				dY = (positionY - xf2.position.y);
				tMat = xf2.R;
				tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				tPoint.separation = (separation - radius);
				return;
			};
			var vertIndex1:int = normalIndex;
			var vertIndex2:int = (((vertIndex1 + 1) < vertexCount)) ? (vertIndex1 + 1) : 0;
			tVec = vertices[vertIndex1];
			var tVec2:b2Vec2 = vertices[vertIndex2];
			var eX:Number = (tVec2.x - tVec.x);
			var eY:Number = (tVec2.y - tVec.y);
			var length:Number = Math.sqrt(((eX * eX) + (eY * eY)));
			eX = (eX / length);
			eY = (eY / length);
			dX = (cLocalX - tVec.x);
			dY = (cLocalY - tVec.y);
			var u:Number = ((dX * eX) + (dY * eY));
			tPoint = manifold.points[0];
			if (u <= 0){
				pX = tVec.x;
				pY = tVec.y;
				tPoint.id.features.incidentEdge = b2_nullFeature;
				tPoint.id.features.incidentVertex = vertIndex1;
			} else {
				if (u >= length){
					pX = tVec2.x;
					pY = tVec2.y;
					tPoint.id.features.incidentEdge = b2_nullFeature;
					tPoint.id.features.incidentVertex = vertIndex2;
				} else {
					pX = ((eX * u) + tVec.x);
					pY = ((eY * u) + tVec.y);
					tPoint.id.features.incidentEdge = normalIndex;
					tPoint.id.features.incidentVertex = b2_nullFeature;
				};
			};
			dX = (cLocalX - pX);
			dY = (cLocalY - pY);
			dist = Math.sqrt(((dX * dX) + (dY * dY)));
			dX = (dX / dist);
			dY = (dY / dist);
			if (dist > radius){
				return;
			};
			manifold.pointCount = 1;
			tMat = xf1.R;
			manifold.normal.x = ((tMat.col1.x * dX) + (tMat.col2.x * dY));
			manifold.normal.y = ((tMat.col1.y * dX) + (tMat.col2.y * dY));
			positionX = (cX - (radius * manifold.normal.x));
			positionY = (cY - (radius * manifold.normal.y));
			dX = (positionX - xf1.position.x);
			dY = (positionY - xf1.position.y);
			tMat = xf1.R;
			tPoint.localPoint1.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			tPoint.localPoint1.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			dX = (positionX - xf2.position.x);
			dY = (positionY - xf2.position.y);
			tMat = xf2.R;
			tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			tPoint.separation = (dist - radius);
			tPoint.id.features.referenceEdge = 0;
			tPoint.id.features.flip = 0;
		}

	}
}//package Box2D.Collision 
Section 21
//b2ContactID (Box2D.Collision.b2ContactID)
package Box2D.Collision {

	public class b2ContactID {

		public var _key:uint;
		public var features:Features;

		public function b2ContactID(){
			features = new Features();
			super();
			features._m_id = this;
		}
		public function Set(id:b2ContactID):void{
			key = id._key;
		}
		public function Copy():b2ContactID{
			var id:b2ContactID = new b2ContactID();
			id.key = key;
			return (id);
		}
		public function set key(value:uint):void{
			_key = value;
			features._referenceEdge = (_key & 0xFF);
			features._incidentEdge = (((_key & 0xFF00) >> 8) & 0xFF);
			features._incidentVertex = (((_key & 0xFF0000) >> 16) & 0xFF);
			features._flip = (((_key & 4278190080) >> 24) & 0xFF);
		}
		public function get key():uint{
			return (_key);
		}

	}
}//package Box2D.Collision 
Section 22
//b2ContactPoint (Box2D.Collision.b2ContactPoint)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2ContactPoint {

		public var friction:Number;
		public var separation:Number;
		public var normal:b2Vec2;
		public var position:b2Vec2;
		public var restitution:Number;
		public var shape1:b2Shape;
		public var shape2:b2Shape;
		public var id:b2ContactID;
		public var velocity:b2Vec2;

		public function b2ContactPoint(){
			position = new b2Vec2();
			velocity = new b2Vec2();
			normal = new b2Vec2();
			id = new b2ContactID();
			super();
		}
	}
}//package Box2D.Collision 
Section 23
//b2Distance (Box2D.Collision.b2Distance)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2Distance {

		public static var s_initialized:Boolean = false;
		public static var g_GJK_Iterations:int = 0;
		private static var s_p1s:Array = [new b2Vec2(), new b2Vec2(), new b2Vec2()];
		public static var s_registers:Array;
		private static var s_p2s:Array = [new b2Vec2(), new b2Vec2(), new b2Vec2()];
		private static var gPoint:b2Point = new b2Point();
		private static var s_points:Array = [new b2Vec2(), new b2Vec2(), new b2Vec2()];
		public static var t:Number = -1;

		public function b2Distance(){
			super();
		}
		public static function DistanceGeneric(x1:b2Vec2, x2:b2Vec2, shape1, xf1:b2XForm, shape2, xf2:b2XForm):Number{
			var tVec:b2Vec2;
			var vX:Number;
			var vY:Number;
			var w1:b2Vec2;
			var w2:b2Vec2;
			var wX:Number;
			var wY:Number;
			var vw:Number;
			var maxSqr:Number;
			var i:int;
			var p1s:Array = s_p1s;
			var p2s:Array = s_p2s;
			var points:Array = s_points;
			var pointCount:int;
			x1.SetV(shape1.GetFirstVertex(xf1));
			x2.SetV(shape2.GetFirstVertex(xf2));
			var vSqr:Number = 0;
			var maxIterations = 20;
			var iter:int;
			while (iter < maxIterations) {
				vX = (x2.x - x1.x);
				vY = (x2.y - x1.y);
				w1 = shape1.Support(xf1, vX, vY);
				w2 = shape2.Support(xf2, -(vX), -(vY));
				vSqr = ((vX * vX) + (vY * vY));
				wX = (w2.x - w1.x);
				wY = (w2.y - w1.y);
				vw = ((vX * wX) + (vY * wY));
				if ((vSqr - vw) <= (0.01 * vSqr)){
					if (pointCount == 0){
						x1.SetV(w1);
						x2.SetV(w2);
					};
					g_GJK_Iterations = iter;
					return (Math.sqrt(vSqr));
				};
				switch (pointCount){
					case 0:
						tVec = p1s[0];
						tVec.SetV(w1);
						tVec = p2s[0];
						tVec.SetV(w2);
						tVec = points[0];
						tVec.x = wX;
						tVec.y = wY;
						x1.SetV(p1s[0]);
						x2.SetV(p2s[0]);
						pointCount++;
						break;
					case 1:
						tVec = p1s[1];
						tVec.SetV(w1);
						tVec = p2s[1];
						tVec.SetV(w2);
						tVec = points[1];
						tVec.x = wX;
						tVec.y = wY;
						pointCount = ProcessTwo(x1, x2, p1s, p2s, points);
						break;
					case 2:
						tVec = p1s[2];
						tVec.SetV(w1);
						tVec = p2s[2];
						tVec.SetV(w2);
						tVec = points[2];
						tVec.x = wX;
						tVec.y = wY;
						pointCount = ProcessThree(x1, x2, p1s, p2s, points);
						break;
				};
				if (pointCount == 3){
					g_GJK_Iterations = iter;
					return (0);
				};
				maxSqr = -(Number.MAX_VALUE);
				i = 0;
				while (i < pointCount) {
					tVec = points[i];
					maxSqr = b2Math.b2Max(maxSqr, ((tVec.x * tVec.x) + (tVec.y * tVec.y)));
					i++;
				};
				if ((((pointCount == 3)) || ((vSqr <= ((100 * Number.MIN_VALUE) * maxSqr))))){
					g_GJK_Iterations = iter;
					vX = (x2.x - x1.x);
					vY = (x2.y - x1.y);
					vSqr = ((vX * vX) + (vY * vY));
					return (Math.sqrt(vSqr));
				};
				iter++;
			};
			g_GJK_Iterations = maxIterations;
			return (Math.sqrt(vSqr));
		}
		public static function InPoints(w:b2Vec2, points:Array, pointCount:int):Boolean{
			var points_i:b2Vec2;
			var dX:Number;
			var dY:Number;
			var mX:Number;
			var mY:Number;
			var k_tolerance:Number = (100 * Number.MIN_VALUE);
			var i:int;
			while (i < pointCount) {
				points_i = points[i];
				dX = Math.abs((w.x - points_i.x));
				dY = Math.abs((w.y - points_i.y));
				mX = Math.max(Math.abs(w.x), Math.abs(points_i.x));
				mY = Math.max(Math.abs(w.y), Math.abs(points_i.y));
				if ((((dX < (k_tolerance * (mX + 1)))) && ((dY < (k_tolerance * (mY + 1)))))){
					return (true);
				};
				i++;
			};
			return (false);
		}
		public static function ProcessThree(x1:b2Vec2, x2:b2Vec2, p1s:Array, p2s:Array, points:Array):int{
			var points_0:b2Vec2;
			var points_1:b2Vec2;
			var points_2:b2Vec2;
			var p1s_0:b2Vec2;
			var p2s_0:b2Vec2;
			var p2s_1:b2Vec2;
			var lambda:Number;
			points_0 = points[0];
			points_1 = points[1];
			points_2 = points[2];
			p1s_0 = p1s[0];
			var p1s_1:b2Vec2 = p1s[1];
			var p1s_2:b2Vec2 = p1s[2];
			p2s_0 = p2s[0];
			p2s_1 = p2s[1];
			var p2s_2:b2Vec2 = p2s[2];
			var aX:Number = points_0.x;
			var aY:Number = points_0.y;
			var bX:Number = points_1.x;
			var bY:Number = points_1.y;
			var cX:Number = points_2.x;
			var cY:Number = points_2.y;
			var abX:Number = (bX - aX);
			var abY:Number = (bY - aY);
			var acX:Number = (cX - aX);
			var acY:Number = (cY - aY);
			var bcX:Number = (cX - bX);
			var bcY:Number = (cY - bY);
			var sn:Number = -(((aX * abX) + (aY * abY)));
			var sd:Number = ((bX * abX) + (bY * abY));
			var tn:Number = -(((aX * acX) + (aY * acY)));
			var td:Number = ((cX * acX) + (cY * acY));
			var un:Number = -(((bX * bcX) + (bY * bcY)));
			var ud:Number = ((cX * bcX) + (cY * bcY));
			if ((((td <= 0)) && ((ud <= 0)))){
				x1.SetV(p1s_2);
				x2.SetV(p2s_2);
				p1s_0.SetV(p1s_2);
				p2s_0.SetV(p2s_2);
				points_0.SetV(points_2);
				return (1);
			};
			var n:Number = ((abX * acY) - (abY * acX));
			var vc:Number = (n * ((aX * bY) - (aY * bX)));
			var va:Number = (n * ((bX * cY) - (bY * cX)));
			if ((((((((va <= 0)) && ((un >= 0)))) && ((ud >= 0)))) && (((un + ud) > 0)))){
				lambda = (un / (un + ud));
				x1.x = (p1s_1.x + (lambda * (p1s_2.x - p1s_1.x)));
				x1.y = (p1s_1.y + (lambda * (p1s_2.y - p1s_1.y)));
				x2.x = (p2s_1.x + (lambda * (p2s_2.x - p2s_1.x)));
				x2.y = (p2s_1.y + (lambda * (p2s_2.y - p2s_1.y)));
				p1s_0.SetV(p1s_2);
				p2s_0.SetV(p2s_2);
				points_0.SetV(points_2);
				return (2);
			};
			var vb:Number = (n * ((cX * aY) - (cY * aX)));
			if ((((((((vb <= 0)) && ((tn >= 0)))) && ((td >= 0)))) && (((tn + td) > 0)))){
				lambda = (tn / (tn + td));
				x1.x = (p1s_0.x + (lambda * (p1s_2.x - p1s_0.x)));
				x1.y = (p1s_0.y + (lambda * (p1s_2.y - p1s_0.y)));
				x2.x = (p2s_0.x + (lambda * (p2s_2.x - p2s_0.x)));
				x2.y = (p2s_0.y + (lambda * (p2s_2.y - p2s_0.y)));
				p1s_1.SetV(p1s_2);
				p2s_1.SetV(p2s_2);
				points_1.SetV(points_2);
				return (2);
			};
			var denom:Number = ((va + vb) + vc);
			denom = (1 / denom);
			var u:Number = (va * denom);
			var v:Number = (vb * denom);
			var w:Number = ((1 - u) - v);
			x1.x = (((u * p1s_0.x) + (v * p1s_1.x)) + (w * p1s_2.x));
			x1.y = (((u * p1s_0.y) + (v * p1s_1.y)) + (w * p1s_2.y));
			x2.x = (((u * p2s_0.x) + (v * p2s_1.x)) + (w * p2s_2.x));
			x2.y = (((u * p2s_0.y) + (v * p2s_1.y)) + (w * p2s_2.y));
			return (3);
		}
		public static function Distance(x1:b2Vec2, x2:b2Vec2, shape1:b2Shape, xf1:b2XForm, shape2:b2Shape, xf2:b2XForm):Number{
			var type1:int = shape1.GetType();
			var type2:int = shape2.GetType();
			var register:b2DistanceRegister = s_registers[(type1 + (type2 * b2Shape.e_shapeTypeCount))];
			if (register != null){
				if (register.primary){
					return (register.fcn(x1, x2, shape1, xf1, shape2, xf2));
				};
				return (register.fcn(x2, x1, shape2, xf2, shape1, xf1));
			};
			return (0);
		}
		public static function DistancePC(x1:b2Vec2, x2:b2Vec2, polygon:b2PolygonShape, xf1:b2XForm, circle:b2CircleShape, xf2:b2XForm):Number{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var dX:Number;
			var dY:Number;
			var dLen:Number;
			var point:b2Point = gPoint;
			tVec = circle.m_localPosition;
			tMat = xf2.R;
			point.p.x = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			point.p.y = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			var distance:Number = DistanceGeneric(x1, x2, polygon, xf1, point, b2Math.b2XForm_identity);
			var r:Number = (circle.m_radius - b2Settings.b2_toiSlop);
			if (distance > r){
				distance = (distance - r);
				dX = (x2.x - x1.x);
				dY = (x2.y - x1.y);
				dLen = Math.sqrt(((dX * dX) + (dY * dY)));
				dX = (dX / dLen);
				dY = (dY / dLen);
				x2.x = (x2.x - (r * dX));
				x2.y = (x2.y - (r * dY));
			} else {
				distance = 0;
				x2.x = x1.x;
				x2.y = x1.y;
			};
			return (distance);
		}
		public static function AddType(fcn:Function, type1:int, type2:int):void{
			s_registers[(type1 + (type2 * b2Shape.e_shapeTypeCount))] = new b2DistanceRegister(fcn, true);
			if (type1 != type2){
				s_registers[(type2 + (type1 * b2Shape.e_shapeTypeCount))] = new b2DistanceRegister(fcn, false);
			};
		}
		public static function DistanceSeC(x1:b2Vec2, x2:b2Vec2, edge:b2StaticEdgeShape, xf1:b2XForm, circle:b2CircleShape, xf2:b2XForm):Number{
			var dX:Number;
			var dY:Number;
			var dSqr:Number;
			var dLen:Number;
			var tPoint:b2ManifoldPoint;
			var r:Number = (circle.m_radius - b2Settings.b2_toiSlop);
			var tMat:b2Mat22 = xf2.R;
			var tVec:b2Vec2 = circle.m_localPosition;
			var circleX:Number = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var circleY:Number = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tVec = edge.m_direction;
			var dirDist:Number = (((circleX - edge.m_coreV1.x) * tVec.x) + ((circleY - edge.m_coreV1.y) * tVec.y));
			if (dirDist <= 0){
				x1.SetV(edge.m_coreV1);
				dX = (circleX - edge.m_coreV1.x);
				dY = (circleY - edge.m_coreV1.y);
				dSqr = ((dX * dX) + (dY * dY));
				if (dSqr > (r * r)){
					dLen = Math.sqrt(dSqr);
					dX = (dX / dLen);
					dY = (dY / dLen);
					x2.x = (circleX - (dX * r));
					x2.y = (circleY - (dY * r));
					return ((dLen - r));
				};
				x2.SetV(edge.m_coreV1);
				return (0);
			} else {
				if (dirDist >= edge.m_length){
					x1.SetV(edge.m_coreV2);
					dX = (circleX - edge.m_coreV2.x);
					dY = (circleY - edge.m_coreV2.y);
					dSqr = ((dX * dX) + (dY * dY));
					if (dSqr > (r * r)){
						dLen = Math.sqrt(dSqr);
						dX = (dX / dLen);
						dY = (dY / dLen);
						x2.x = (circleX - (dX * r));
						x2.y = (circleY - (dY * r));
						return ((dLen - r));
					};
					x2.SetV(edge.m_coreV2);
					return (0);
					//unresolved jump
				};
				x1.x = (edge.m_coreV1.x + (tVec.x * dirDist));
				x1.y = (edge.m_coreV1.y + (tVec.y * dirDist));
				tVec = edge.m_normal;
				dLen = (((circleX - edge.m_coreV1.x) * tVec.x) + ((circleY - edge.m_coreV1.y) * tVec.y));
				if (dLen < 0){
					if (dLen < -(r)){
						x2.x = (circleX + (r * tVec.x));
						x2.y = (circleY + (r * tVec.y));
						return ((-(dLen) - r));
					};
					x2.SetV(x1);
					return (0);
					//unresolved jump
				};
				//unresolved if
				x2.x = (circleX - (r * tVec.x));
			};
			((!NULL!.y * !NULL!) - !NULL!).y = !NULL!;
			return ((dLen - r));
			x2.SetV(x1);
			return (0);
		}
		public static function DistanceCcaC(x1:b2Vec2, x2:b2Vec2, polygon:b2ConcaveArcShape, xf1:b2XForm, circle:b2CircleShape, xf2:b2XForm):Number{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var arcCenter:b2Vec2;
			var c2X:Number;
			var c2Y:Number;
			var norm:Number;
			var c:Number;
			var dX:Number;
			var dY:Number;
			var dLen:Number;
			var point:b2Point = gPoint;
			tVec = circle.m_localPosition;
			tMat = xf2.R;
			point.p.x = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			point.p.y = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			var distance:Number = DistanceGeneric(x1, x2, polygon, xf1, point, b2Math.b2XForm_identity);
			var r:Number = (circle.m_radius - b2Settings.b2_toiSlop);
			var vx0:b2Vec2 = b2Math.b2MulX(xf1, polygon.m_coreVertices[0]);
			var normal:b2Vec2 = b2Math.b2MulMV(xf1.R, polygon.m_normals[0]);
			var n:Number = (((x1.x - vx0.x) * normal.x) + ((x1.y - vx0.y) * normal.y));
			if (n >= 0){
				arcCenter = b2Math.b2MulX(xf1, polygon.m_arcCenter);
				c2X = (point.p.x - arcCenter.x);
				c2Y = (point.p.y - arcCenter.y);
				norm = ((-(normal.y) * c2X) + (normal.x * c2Y));
				if (((c2X * normal.x) + (c2Y * normal.y)) > 0){
					if (norm < 0){
						tVec = vx0;
					} else {
						tVec = b2Math.b2MulX(xf1, polygon.m_coreVertices[1]);
					};
				} else {
					if (norm <= -(polygon.m_norm)){
						tVec = vx0;
					} else {
						if (norm >= polygon.m_norm){
							tVec = b2Math.b2MulX(xf1, polygon.m_coreVertices[1]);
						} else {
							c = Math.sqrt(((c2X * c2X) + (c2Y * c2Y)));
							distance = (((polygon.m_radius + (b2Settings.b2_toiSlop * 2)) - r) - c);
							c2X = (c2X / c);
							c2Y = (c2Y / c);
							if (distance < 0){
								distance = 0;
							};
							x1.x = (arcCenter.x + (c2X * (polygon.m_radius + b2Settings.b2_toiSlop)));
							x1.y = (arcCenter.y + (c2Y * (polygon.m_radius + b2Settings.b2_toiSlop)));
							x2.x = (x2.x + (c2X * r));
							x2.y = (x2.y + (c2Y * r));
							return (distance);
						};
					};
				};
				x1.SetV(tVec);
				tVec.x = (tVec.x - point.p.x);
				tVec.y = (tVec.y - point.p.y);
				distance = (tVec.Normalize() - r);
				if (distance > 0){
					x2.x = (x2.x + (r * tVec.x));
					x2.y = (x2.y + (r * tVec.y));
					return (distance);
				};
				x2.SetV(x1);
				return (0);
			};
			if (distance > r){
				distance = (distance - r);
				dX = (x2.x - x1.x);
				dY = (x2.y - x1.y);
				dLen = Math.sqrt(((dX * dX) + (dY * dY)));
				dX = (dX / dLen);
				dY = (dY / dLen);
				x2.x = (x2.x - (r * dX));
				x2.y = (x2.y - (r * dY));
			} else {
				distance = 0;
				x2.x = x1.x;
				x2.y = x1.y;
			};
			return (distance);
		}
		public static function InitializeRegisters():void{
			if (s_initialized == true){
				return;
			};
			s_initialized = true;
			s_registers = new Array((b2Shape.e_shapeTypeCount * b2Shape.e_shapeTypeCount));
			AddType(b2Distance.DistanceCC, b2Shape.e_circleShape, b2Shape.e_circleShape);
			AddType(b2Distance.DistancePC, b2Shape.e_polygonShape, b2Shape.e_circleShape);
			AddType(b2Distance.DistanceGeneric, b2Shape.e_polygonShape, b2Shape.e_polygonShape);
			AddType(b2Distance.DistanceCcaC, b2Shape.e_concaveArcShape, b2Shape.e_circleShape);
			AddType(b2Distance.DistancePCca, b2Shape.e_polygonShape, b2Shape.e_concaveArcShape);
			AddType(b2Distance.DistanceSeC, b2Shape.e_staticEdgeShape, b2Shape.e_circleShape);
			AddType(b2Distance.DistanceGeneric, b2Shape.e_polygonShape, b2Shape.e_staticEdgeShape);
		}
		public static function DistancePCca(x1:b2Vec2, x2:b2Vec2, polygon:b2PolygonShape, xf1:b2XForm, arc:b2ConcaveArcShape, xf2:b2XForm):Number{
			var dist2:Number;
			var dist:Number;
			var norm:Number;
			t = -1;
			var gd:Number = DistanceGeneric(x1, x2, polygon, xf1, arc, xf2);
			var vx0:b2Vec2 = b2Math.b2MulX(xf2, arc.m_coreVertices[0]);
			var normal:b2Vec2 = b2Math.b2MulMV(xf2.R, arc.m_normals[0]);
			var n:Number = (((x2.x - vx0.x) * normal.x) + ((x2.y - vx0.y) * normal.y));
			if ((((n < (-(b2Settings.b2_linearSlop) / 4))) && ((gd > 0)))){
				t = 0;
				return (gd);
			};
			var vx1:b2Vec2 = b2Math.b2MulX(xf2, arc.m_coreVertices[1]);
			var tVec:b2Vec2 = new b2Vec2();
			var tolerance:Number = (b2Settings.b2_linearSlop * b2Settings.b2_linearSlop);
			tVec.x = (vx0.x - x2.x);
			tVec.y = (vx0.y - x2.y);
			if (((tVec.x * tVec.x) + (tVec.y * tVec.y)) < tolerance){
				t = 1;
				return (gd);
			};
			tVec.x = (vx1.x - x2.x);
			tVec.y = (vx1.y - x2.y);
			if (((tVec.x * tVec.x) + (tVec.y * tVec.y)) < tolerance){
				t = 2;
				return (gd);
			};
			var localCenter:b2Vec2 = b2Math.b2MulXT(xf1, b2Math.b2MulX(xf2, arc.m_arcCenter));
			var localNorm:b2Vec2 = b2Math.b2MulTMV(xf1.R, normal);
			var maxDist2:Number = -1;
			var bestVx:Number = -1;
			var separation:Number = Number.MAX_VALUE;
			var i:Number = 0;
			while (i < polygon.m_vertexCount) {
				tVec.x = (polygon.m_coreVertices[i].x - localCenter.x);
				tVec.y = (polygon.m_coreVertices[i].y - localCenter.y);
				norm = ((tVec.x * localNorm.y) - (tVec.y * localNorm.x));
				dist2 = ((tVec.x * tVec.x) + (tVec.y * tVec.y));
				if (((((norm * norm) < ((arc.m_norm * arc.m_norm) * dist2))) && ((((tVec.x * localNorm.x) + (tVec.y * localNorm.y)) < 0)))){
					if (dist2 > maxDist2){
						maxDist2 = dist2;
						bestVx = i;
						dist = Math.sqrt(dist2);
						separation = ((arc.m_radius + b2Settings.b2_toiSlop) - dist);
						if (separation < 0){
							separation = 0;
						};
						x1.SetV(b2Math.b2MulX(xf1, polygon.m_coreVertices[i]));
						tVec.x = (tVec.x * ((arc.m_radius + b2Settings.b2_toiSlop) / dist));
						tVec.y = (tVec.y * ((arc.m_radius + b2Settings.b2_toiSlop) / dist));
						tVec.x = (tVec.x + localCenter.x);
						tVec.y = (tVec.y + localCenter.y);
						x2.SetV(b2Math.b2MulX(xf1, tVec));
						t = 3;
					};
				};
				i++;
			};
			var sx1:b2Vec2 = new b2Vec2();
			var sx2:b2Vec2 = new b2Vec2();
			var point:b2Point = gPoint;
			point.p.SetV(vx0);
			var anotherDistance:Number = DistanceGeneric(sx1, sx2, polygon, xf1, point, b2Math.b2XForm_identity);
			if (anotherDistance < separation){
				t = 4;
				separation = anotherDistance;
				x1.SetV(sx1);
				x2.SetV(sx2);
			};
			point.p.SetV(vx1);
			anotherDistance = DistanceGeneric(sx1, sx2, polygon, xf1, point, b2Math.b2XForm_identity);
			if (anotherDistance < separation){
				t = 5;
				separation = anotherDistance;
				x1.SetV(sx1);
				x2.SetV(sx2);
			};
			return (separation);
		}
		public static function DistanceCC(x1:b2Vec2, x2:b2Vec2, circle1:b2CircleShape, xf1:b2XForm, circle2:b2CircleShape, xf2:b2XForm):Number{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var dLen:Number;
			var distance:Number;
			tMat = xf1.R;
			tVec = circle1.m_localPosition;
			var p1X:Number = (xf1.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var p1Y:Number = (xf1.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			tMat = xf2.R;
			tVec = circle2.m_localPosition;
			var p2X:Number = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			var p2Y:Number = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			var dX:Number = (p2X - p1X);
			var dY:Number = (p2Y - p1Y);
			var dSqr:Number = ((dX * dX) + (dY * dY));
			var r1:Number = (circle1.m_radius - b2Settings.b2_toiSlop);
			var r2:Number = (circle2.m_radius - b2Settings.b2_toiSlop);
			var r:Number = (r1 + r2);
			if (dSqr > (r * r)){
				dLen = Math.sqrt(dSqr);
				dX = (dX / dLen);
				dY = (dY / dLen);
				distance = (dLen - r);
				x1.x = (p1X + (r1 * dX));
				x1.y = (p1Y + (r1 * dY));
				x2.x = (p2X - (r2 * dX));
				x2.y = (p2Y - (r2 * dY));
				return (distance);
			};
			if (dSqr > (Number.MIN_VALUE * Number.MIN_VALUE)){
				dLen = Math.sqrt(dSqr);
				dX = (dX / dLen);
				dY = (dY / dLen);
				x1.x = (p1X + (r1 * dX));
				x1.y = (p1Y + (r1 * dY));
				x2.x = x1.x;
				x2.y = x1.y;
				return (0);
			};
			x1.x = p1X;
			x1.y = p1Y;
			x2.x = x1.x;
			x2.y = x1.y;
			return (0);
		}
		public static function ProcessTwo(x1:b2Vec2, x2:b2Vec2, p1s:Array, p2s:Array, points:Array):int{
			var p1s_1:b2Vec2;
			var p2s_0:b2Vec2;
			var points_0:b2Vec2 = points[0];
			var points_1:b2Vec2 = points[1];
			var p1s_0:b2Vec2 = p1s[0];
			p1s_1 = p1s[1];
			p2s_0 = p2s[0];
			var p2s_1:b2Vec2 = p2s[1];
			var rX:Number = -(points_1.x);
			var rY:Number = -(points_1.y);
			var dX:Number = (points_0.x - points_1.x);
			var dY:Number = (points_0.y - points_1.y);
			var length:Number = Math.sqrt(((dX * dX) + (dY * dY)));
			dX = (dX / length);
			dY = (dY / length);
			var lambda:Number = ((rX * dX) + (rY * dY));
			if ((((lambda <= 0)) || ((length < Number.MIN_VALUE)))){
				x1.SetV(p1s_1);
				x2.SetV(p2s_1);
				p1s_0.SetV(p1s_1);
				p2s_0.SetV(p2s_1);
				points_0.SetV(points_1);
				return (1);
			};
			lambda = (lambda / length);
			x1.x = (p1s_1.x + (lambda * (p1s_0.x - p1s_1.x)));
			x1.y = (p1s_1.y + (lambda * (p1s_0.y - p1s_1.y)));
			x2.x = (p2s_1.x + (lambda * (p2s_0.x - p2s_1.x)));
			x2.y = (p2s_1.y + (lambda * (p2s_0.y - p2s_1.y)));
			return (2);
		}

	}
}//package Box2D.Collision 
Section 24
//b2DistanceRegister (Box2D.Collision.b2DistanceRegister)
package Box2D.Collision {

	public class b2DistanceRegister {

		public var fcn:Function;
		public var primary:Boolean;

		public function b2DistanceRegister(fcn:Function, primary:Boolean){
			super();
			this.fcn = fcn;
			this.primary = primary;
		}
	}
}//package Box2D.Collision 
Section 25
//b2Manifold (Box2D.Collision.b2Manifold)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2Manifold {

		public var pointCount:int;// = 0
		public var normal:b2Vec2;
		public var points:Array;

		public function b2Manifold(){
			super();
			points = new Array(b2Settings.b2_maxManifoldPoints);
			var i:int;
			while (i < b2Settings.b2_maxManifoldPoints) {
				points[i] = new b2ManifoldPoint();
				i++;
			};
			normal = new b2Vec2();
		}
		public function Set(m:b2Manifold):void{
			pointCount = m.pointCount;
			var i:int;
			while (i < b2Settings.b2_maxManifoldPoints) {
				(points[i] as b2ManifoldPoint).Set(m.points[i]);
				i++;
			};
			normal.SetV(m.normal);
		}
		public function Reset():void{
			var i:int;
			while (i < b2Settings.b2_maxManifoldPoints) {
				(points[i] as b2ManifoldPoint).Reset();
				i++;
			};
			normal.SetZero();
			pointCount = 0;
		}

	}
}//package Box2D.Collision 
Section 26
//b2ManifoldPoint (Box2D.Collision.b2ManifoldPoint)
package Box2D.Collision {
	import Box2D.Common.Math.*;

	public class b2ManifoldPoint {

		public var separation:Number;
		public var localPoint2:b2Vec2;
		public var normalImpulse:Number;
		public var tangentImpulse:Number;
		public var localPoint1:b2Vec2;
		public var id:b2ContactID;

		public function b2ManifoldPoint(){
			localPoint1 = new b2Vec2();
			localPoint2 = new b2Vec2();
			id = new b2ContactID();
			super();
		}
		public function Set(m:b2ManifoldPoint):void{
			localPoint1.SetV(m.localPoint1);
			localPoint2.SetV(m.localPoint2);
			separation = m.separation;
			normalImpulse = m.normalImpulse;
			tangentImpulse = m.tangentImpulse;
			id.key = m.id.key;
		}
		public function Reset():void{
			localPoint1.SetZero();
			localPoint2.SetZero();
			separation = 0;
			normalImpulse = 0;
			tangentImpulse = 0;
			id.key = 0;
		}

	}
}//package Box2D.Collision 
Section 27
//b2OBB (Box2D.Collision.b2OBB)
package Box2D.Collision {
	import Box2D.Common.Math.*;

	public class b2OBB {

		public var R:b2Mat22;
		public var center:b2Vec2;
		public var extents:b2Vec2;

		public function b2OBB(){
			R = new b2Mat22();
			center = new b2Vec2();
			extents = new b2Vec2();
			super();
		}
	}
}//package Box2D.Collision 
Section 28
//b2Pair (Box2D.Collision.b2Pair)
package Box2D.Collision {
	import Box2D.Common.*;

	public class b2Pair {

		public var proxyId1:uint;
		public var userData;// = null
		public var proxyId2:uint;
		public var status:uint;
		public var next:uint;

		public static var e_pairFinal:uint = 4;
		public static var b2_tableMask:int = (b2_tableCapacity - 1);
		public static var e_pairRemoved:uint = 2;
		public static var b2_nullPair:uint = b2Settings.USHRT_MAX;
		public static var e_pairBuffered:uint = 1;
		public static var b2_nullProxy:uint = b2Settings.USHRT_MAX;
		public static var b2_tableCapacity:int = b2Settings.b2_maxPairs;

		public function b2Pair(){
			super();
		}
		public function SetBuffered():void{
			status = (status | e_pairBuffered);
		}
		public function IsBuffered():Boolean{
			return (((status & e_pairBuffered) == e_pairBuffered));
		}
		public function IsFinal():Boolean{
			return (((status & e_pairFinal) == e_pairFinal));
		}
		public function ClearRemoved():void{
			status = (status & ~(e_pairRemoved));
		}
		public function SetFinal():void{
			status = (status | e_pairFinal);
		}
		public function IsRemoved():Boolean{
			return (((status & e_pairRemoved) == e_pairRemoved));
		}
		public function ClearBuffered():void{
			status = (status & ~(e_pairBuffered));
		}
		public function SetRemoved():void{
			status = (status | e_pairRemoved);
		}

	}
}//package Box2D.Collision 
Section 29
//b2PairCallback (Box2D.Collision.b2PairCallback)
package Box2D.Collision {

	public class b2PairCallback {

		public function b2PairCallback(){
			super();
		}
		public function PairRemoved(proxyUserData1, proxyUserData2, pairUserData):void{
		}
		public function PairAdded(proxyUserData1, proxyUserData2){
			return (null);
		}

	}
}//package Box2D.Collision 
Section 30
//b2PairManager (Box2D.Collision.b2PairManager)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2PairManager {

		public var m_pairCount:int;
		public var m_pairBuffer:Array;
		public var m_hashTable:Array;
		public var m_callback:b2PairCallback;
		public var m_pairs:Array;
		public var m_pairBufferCount:int;
		public var m_broadPhase:b2BroadPhase;
		public var m_freePair:uint;

		public function b2PairManager(){
			var i:uint;
			super();
			m_hashTable = new Array(b2Pair.b2_tableCapacity);
			i = 0;
			while (i < b2Pair.b2_tableCapacity) {
				m_hashTable[i] = b2Pair.b2_nullPair;
				i++;
			};
			m_pairs = new Array(b2Settings.b2_maxPairs);
			i = 0;
			while (i < b2Settings.b2_maxPairs) {
				m_pairs[i] = new b2Pair();
				i++;
			};
			m_pairBuffer = new Array(b2Settings.b2_maxPairs);
			i = 0;
			while (i < b2Settings.b2_maxPairs) {
				m_pairBuffer[i] = new b2BufferedPair();
				i++;
			};
			i = 0;
			while (i < b2Settings.b2_maxPairs) {
				m_pairs[i].proxyId1 = b2Pair.b2_nullProxy;
				m_pairs[i].proxyId2 = b2Pair.b2_nullProxy;
				m_pairs[i].userData = null;
				m_pairs[i].status = 0;
				m_pairs[i].next = (i + 1);
				i++;
			};
			m_pairs[int((b2Settings.b2_maxPairs - 1))].next = b2Pair.b2_nullPair;
			m_pairCount = 0;
			m_pairBufferCount = 0;
		}
		private function FindHash(proxyId1:uint, proxyId2:uint, hash:uint):b2Pair{
			var pair:b2Pair;
			var index:uint = m_hashTable[hash];
			pair = m_pairs[index];
			while (((!((index == b2Pair.b2_nullPair))) && ((Equals(pair, proxyId1, proxyId2) == false)))) {
				index = pair.next;
				pair = m_pairs[index];
			};
			if (index == b2Pair.b2_nullPair){
				return (null);
			};
			return (pair);
		}
		private function Find(proxyId1:uint, proxyId2:uint):b2Pair{
			var temp:uint;
			if (proxyId1 > proxyId2){
				temp = proxyId1;
				proxyId1 = proxyId2;
				proxyId2 = temp;
			};
			var hash:uint = (Hash(proxyId1, proxyId2) & b2Pair.b2_tableMask);
			return (FindHash(proxyId1, proxyId2, hash));
		}
		private function ValidateBuffer():void{
		}
		public function Commit():void{
			var bufferedPair:b2BufferedPair;
			var i:int;
			var pair:b2Pair;
			var proxy1:b2Proxy;
			var proxy2:b2Proxy;
			var removeCount:int;
			var proxies:Array = m_broadPhase.m_proxyPool;
			i = 0;
			while (i < m_pairBufferCount) {
				bufferedPair = m_pairBuffer[i];
				pair = Find(bufferedPair.proxyId1, bufferedPair.proxyId2);
				pair.ClearBuffered();
				proxy1 = proxies[pair.proxyId1];
				proxy2 = proxies[pair.proxyId2];
				if (pair.IsRemoved()){
					if (pair.IsFinal() == true){
						m_callback.PairRemoved(proxy1.userData, proxy2.userData, pair.userData);
					};
					bufferedPair = m_pairBuffer[removeCount];
					bufferedPair.proxyId1 = pair.proxyId1;
					bufferedPair.proxyId2 = pair.proxyId2;
					removeCount++;
				} else {
					if (pair.IsFinal() == false){
						pair.userData = m_callback.PairAdded(proxy1.userData, proxy2.userData);
						pair.SetFinal();
					};
				};
				i++;
			};
			i = 0;
			while (i < removeCount) {
				bufferedPair = m_pairBuffer[i];
				RemovePair(bufferedPair.proxyId1, bufferedPair.proxyId2);
				i++;
			};
			m_pairBufferCount = 0;
			if (b2BroadPhase.s_validate){
				ValidateTable();
			};
		}
		public function RemoveBufferedPair(proxyId1:int, proxyId2:int):void{
			var bufferedPair:b2BufferedPair;
			var pair:b2Pair = Find(proxyId1, proxyId2);
			if (pair == null){
				return;
			};
			if (pair.IsBuffered() == false){
				pair.SetBuffered();
				bufferedPair = m_pairBuffer[m_pairBufferCount];
				bufferedPair.proxyId1 = pair.proxyId1;
				bufferedPair.proxyId2 = pair.proxyId2;
				m_pairBufferCount++;
			};
			pair.SetRemoved();
			if (b2BroadPhase.s_validate){
				ValidateBuffer();
			};
		}
		private function RemovePair(proxyId1:uint, proxyId2:uint){
			var pair:b2Pair;
			var temp:uint;
			var index:uint;
			var userData:*;
			if (proxyId1 > proxyId2){
				temp = proxyId1;
				proxyId1 = proxyId2;
				proxyId2 = temp;
			};
			var hash:uint = (Hash(proxyId1, proxyId2) & b2Pair.b2_tableMask);
			var node:uint = m_hashTable[hash];
			var pNode:b2Pair;
			while (node != b2Pair.b2_nullPair) {
				if (Equals(m_pairs[node], proxyId1, proxyId2)){
					index = node;
					pair = m_pairs[node];
					if (pNode){
						pNode.next = pair.next;
					} else {
						m_hashTable[hash] = pair.next;
					};
					pair = m_pairs[index];
					userData = pair.userData;
					pair.next = m_freePair;
					pair.proxyId1 = b2Pair.b2_nullProxy;
					pair.proxyId2 = b2Pair.b2_nullProxy;
					pair.userData = null;
					pair.status = 0;
					m_freePair = index;
					m_pairCount--;
					return (userData);
				} else {
					pNode = m_pairs[node];
					node = pNode.next;
				};
			};
			return (null);
		}
		public function Initialize(broadPhase:b2BroadPhase, callback:b2PairCallback):void{
			m_broadPhase = broadPhase;
			m_callback = callback;
		}
		public function AddBufferedPair(proxyId1:int, proxyId2:int):void{
			var bufferedPair:b2BufferedPair;
			var pair:b2Pair = AddPair(proxyId1, proxyId2);
			if (pair.IsBuffered() == false){
				pair.SetBuffered();
				bufferedPair = m_pairBuffer[m_pairBufferCount];
				bufferedPair.proxyId1 = pair.proxyId1;
				bufferedPair.proxyId2 = pair.proxyId2;
				m_pairBufferCount++;
			};
			pair.ClearRemoved();
			if (b2BroadPhase.s_validate){
				ValidateBuffer();
			};
		}
		private function AddPair(proxyId1:uint, proxyId2:uint):b2Pair{
			var temp:uint;
			if (proxyId1 > proxyId2){
				temp = proxyId1;
				proxyId1 = proxyId2;
				proxyId2 = temp;
			};
			var hash:uint = (Hash(proxyId1, proxyId2) & b2Pair.b2_tableMask);
			var pair = FindHash(proxyId1, proxyId2, hash);
			if (pair != null){
				return (pair);
			};
			var pIndex:uint = m_freePair;
			pair = m_pairs[pIndex];
			m_freePair = pair.next;
			pair.proxyId1 = proxyId1;
			pair.proxyId2 = proxyId2;
			pair.status = 0;
			pair.userData = null;
			pair.next = m_hashTable[hash];
			m_hashTable[hash] = pIndex;
			m_pairCount++;
			return (pair);
		}
		private function ValidateTable():void{
		}

		public static function EqualsPair(pair1:b2BufferedPair, pair2:b2BufferedPair):Boolean{
			return ((((pair1.proxyId1 == pair2.proxyId1)) && ((pair1.proxyId2 == pair2.proxyId2))));
		}
		public static function Hash(proxyId1:uint, proxyId2:uint):uint{
			var key:uint = (((proxyId2 << 16) & 4294901760) | proxyId1);
			key = (~(key) + ((key << 15) & 4294934528));
			key = (key ^ ((key >> 12) & 1048575));
			key = (key + ((key << 2) & 4294967292));
			key = (key ^ ((key >> 4) & 268435455));
			key = (key * 2057);
			key = (key ^ ((key >> 16) & 0xFFFF));
			return (key);
		}
		public static function Equals(pair:b2Pair, proxyId1:uint, proxyId2:uint):Boolean{
			return ((((pair.proxyId1 == proxyId1)) && ((pair.proxyId2 == proxyId2))));
		}

	}
}//package Box2D.Collision 
Section 31
//b2Point (Box2D.Collision.b2Point)
package Box2D.Collision {
	import Box2D.Common.Math.*;

	public class b2Point {

		public var p:b2Vec2;

		public function b2Point(){
			p = new b2Vec2();
			super();
		}
		public function GetFirstVertex(xf:b2XForm):b2Vec2{
			return (p);
		}
		public function Support(xf:b2XForm, vX:Number, vY:Number):b2Vec2{
			return (p);
		}

	}
}//package Box2D.Collision 
Section 32
//b2Proxy (Box2D.Collision.b2Proxy)
package Box2D.Collision {

	public class b2Proxy {

		public var overlapCount:uint;
		public var userData;// = null
		public var lowerBounds:Array;
		public var upperBounds:Array;
		public var timeStamp:uint;

		public function b2Proxy(){
			lowerBounds = [uint(0), uint(0)];
			upperBounds = [uint(0), uint(0)];
			super();
		}
		public function GetNext():uint{
			return (lowerBounds[0]);
		}
		public function IsValid():Boolean{
			return (!((overlapCount == b2BroadPhase.b2_invalid)));
		}
		public function SetNext(next:uint):void{
			lowerBounds[0] = (next & 0xFFFF);
		}

	}
}//package Box2D.Collision 
Section 33
//b2Segment (Box2D.Collision.b2Segment)
package Box2D.Collision {
	import Box2D.Common.Math.*;

	public class b2Segment {

		public var p1:b2Vec2;
		public var p2:b2Vec2;

		public function b2Segment(){
			p1 = new b2Vec2();
			p2 = new b2Vec2();
			super();
		}
		public function TestSegment(lambda:Array, normal:b2Vec2, segment:b2Segment, maxLambda:Number):Boolean{
			var bX:Number;
			var bY:Number;
			var a:Number;
			var mu2:Number;
			var nLen:Number;
			var s:b2Vec2 = segment.p1;
			var rX:Number = (segment.p2.x - s.x);
			var rY:Number = (segment.p2.y - s.y);
			var dX:Number = (p2.x - p1.x);
			var dY:Number = (p2.y - p1.y);
			var nX:Number = dY;
			var nY:Number = -(dX);
			var k_slop:Number = (100 * Number.MIN_VALUE);
			var denom:Number = -(((rX * nX) + (rY * nY)));
			if (denom > k_slop){
				bX = (s.x - p1.x);
				bY = (s.y - p1.y);
				a = ((bX * nX) + (bY * nY));
				if ((((0 <= a)) && ((a <= (maxLambda * denom))))){
					mu2 = ((-(rX) * bY) + (rY * bX));
					if (((((-(k_slop) * denom) <= mu2)) && ((mu2 <= (denom * (1 + k_slop)))))){
						a = (a / denom);
						nLen = Math.sqrt(((nX * nX) + (nY * nY)));
						nX = (nX / nLen);
						nY = (nY / nLen);
						lambda[0] = a;
						normal.Set(nX, nY);
						return (true);
					};
				};
			};
			return (false);
		}

	}
}//package Box2D.Collision 
Section 34
//b2TimeOfImpact (Box2D.Collision.b2TimeOfImpact)
package Box2D.Collision {
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2TimeOfImpact {

		public static var s_xf1:b2XForm = new b2XForm();
		public static var s_xf2:b2XForm = new b2XForm();
		public static var s_p1:b2Vec2 = new b2Vec2();
		public static var s_p2:b2Vec2 = new b2Vec2();

		public function b2TimeOfImpact(){
			super();
		}
		public static function TimeOfImpact(shape1:b2Shape, sweep1:b2Sweep, shape2:b2Shape, sweep2:b2Sweep):Number{
			var math1:Number;
			var math2:Number;
			var t:Number;
			var xf1:b2XForm;
			var xf2:b2XForm;
			var nLen:Number;
			var approachVelocityBound:Number;
			var dAlpha:Number;
			var newAlpha:Number;
			var r1:Number = shape1.m_sweepRadius;
			var r2:Number = shape2.m_sweepRadius;
			var t0:Number = sweep1.t0;
			var v1X:Number = (sweep1.c.x - sweep1.c0.x);
			var v1Y:Number = (sweep1.c.y - sweep1.c0.y);
			var v2X:Number = (sweep2.c.x - sweep2.c0.x);
			var v2Y:Number = (sweep2.c.y - sweep2.c0.y);
			var omega1:Number = (sweep1.a - sweep1.a0);
			var omega2:Number = (sweep2.a - sweep2.a0);
			var alpha:Number = 0;
			var p1:b2Vec2 = s_p1;
			var p2:b2Vec2 = s_p2;
			var k_maxIterations = 20;
			var iter:int;
			var normalX:Number = 0;
			var normalY:Number = 0;
			var distance:Number = 0;
			var targetDistance:Number = 0;
			while (true) {
				t = (((1 - alpha) * t0) + alpha);
				xf1 = s_xf1;
				xf2 = s_xf2;
				sweep1.GetXForm(xf1, t);
				sweep2.GetXForm(xf2, t);
				distance = b2Distance.Distance(p1, p2, shape1, xf1, shape2, xf2);
				if (iter == 0){
					if (distance > (2 * b2Settings.b2_toiSlop)){
						targetDistance = (1.5 * b2Settings.b2_toiSlop);
					} else {
						math1 = (0.05 * b2Settings.b2_toiSlop);
						math2 = (distance - (0.5 * b2Settings.b2_toiSlop));
						targetDistance = ((math1 > math2)) ? math1 : math2;
					};
				};
				if (((((distance - targetDistance) < (0.05 * b2Settings.b2_toiSlop))) || ((iter == k_maxIterations)))){
					break;
				};
				normalX = (p2.x - p1.x);
				normalY = (p2.y - p1.y);
				nLen = Math.sqrt(((normalX * normalX) + (normalY * normalY)));
				normalX = (normalX / nLen);
				normalY = (normalY / nLen);
				approachVelocityBound = ((((normalX * (v1X - v2X)) + (normalY * (v1Y - v2Y))) + (((omega1 < 0)) ? -(omega1) : omega1 * r1)) + (((omega2 < 0)) ? -(omega2) : omega2 * r2));
				if (approachVelocityBound == 0){
					alpha = 1;
					break;
				};
				dAlpha = ((distance - targetDistance) / approachVelocityBound);
				newAlpha = (alpha + dAlpha);
				if ((((newAlpha < 0)) || ((1 < newAlpha)))){
					alpha = 1;
					break;
				};
				if (newAlpha < ((1 + (100 * Number.MIN_VALUE)) * alpha)){
					break;
				};
				alpha = newAlpha;
				iter++;
			};
			return (alpha);
		}

	}
}//package Box2D.Collision 
Section 35
//ClipVertex (Box2D.Collision.ClipVertex)
package Box2D.Collision {
	import Box2D.Common.Math.*;

	public class ClipVertex {

		public var id:b2ContactID;
		public var v:b2Vec2;

		public function ClipVertex(){
			v = new b2Vec2();
			id = new b2ContactID();
			super();
		}
	}
}//package Box2D.Collision 
Section 36
//Features (Box2D.Collision.Features)
package Box2D.Collision {

	public class Features {

		public var _referenceEdge:int;
		public var _incidentEdge:int;
		public var _flip:int;
		public var _incidentVertex:int;
		public var _m_id:b2ContactID;

		public function Features(){
			super();
		}
		public function get referenceEdge():int{
			return (_referenceEdge);
		}
		public function set incidentVertex(value:int):void{
			_incidentVertex = value;
			_m_id._key = ((_m_id._key & 4278255615) | ((_incidentVertex << 16) & 0xFF0000));
		}
		public function get flip():int{
			return (_flip);
		}
		public function get incidentEdge():int{
			return (_incidentEdge);
		}
		public function set referenceEdge(value:int):void{
			_referenceEdge = value;
			_m_id._key = ((_m_id._key & 4294967040) | (_referenceEdge & 0xFF));
		}
		public function get incidentVertex():int{
			return (_incidentVertex);
		}
		public function set flip(value:int):void{
			_flip = value;
			_m_id._key = ((_m_id._key & 0xFFFFFF) | ((_flip << 24) & 4278190080));
		}
		public function set incidentEdge(value:int):void{
			_incidentEdge = value;
			_m_id._key = ((_m_id._key & 4294902015) | ((_incidentEdge << 8) & 0xFF00));
		}

	}
}//package Box2D.Collision 
Section 37
//b2Mat22 (Box2D.Common.Math.b2Mat22)
package Box2D.Common.Math {

	public class b2Mat22 {

		public var col1:b2Vec2;
		public var col2:b2Vec2;

		public function b2Mat22(angle:Number=0, c1:b2Vec2=null, c2:b2Vec2=null){
			var c:Number;
			var s:Number;
			col1 = new b2Vec2();
			col2 = new b2Vec2();
			super();
			if (((!((c1 == null))) && (!((c2 == null))))){
				col1.SetV(c1);
				col2.SetV(c2);
			} else {
				c = Math.cos(angle);
				s = Math.sin(angle);
				col1.x = c;
				col2.x = -(s);
				col1.y = s;
				col2.y = c;
			};
		}
		public function SetIdentity():void{
			col1.x = 1;
			col2.x = 0;
			col1.y = 0;
			col2.y = 1;
		}
		public function SetVV(c1:b2Vec2, c2:b2Vec2):void{
			col1.SetV(c1);
			col2.SetV(c2);
		}
		public function Set(angle:Number):void{
			var c:Number;
			c = Math.cos(angle);
			var s:Number = Math.sin(angle);
			col1.x = c;
			col2.x = -(s);
			col1.y = s;
			col2.y = c;
		}
		public function SetZero():void{
			col1.x = 0;
			col2.x = 0;
			col1.y = 0;
			col2.y = 0;
		}
		public function SetM(m:b2Mat22):void{
			col1.SetV(m.col1);
			col2.SetV(m.col2);
		}
		public function AddM(m:b2Mat22):void{
			col1.x = (col1.x + m.col1.x);
			col1.y = (col1.y + m.col1.y);
			col2.x = (col2.x + m.col2.x);
			col2.y = (col2.y + m.col2.y);
		}
		public function Abs():void{
			col1.Abs();
			col2.Abs();
		}
		public function Copy():b2Mat22{
			return (new b2Mat22(0, col1, col2));
		}
		public function Invert(out:b2Mat22):b2Mat22{
			var a:Number;
			var c:Number;
			var det:Number;
			a = col1.x;
			var b:Number = col2.x;
			c = col1.y;
			var d:Number = col2.y;
			det = ((a * d) - (b * c));
			det = (1 / det);
			out.col1.x = (det * d);
			out.col2.x = (-(det) * b);
			out.col1.y = (-(det) * c);
			out.col2.y = (det * a);
			return (out);
		}
		public function GetAngle():Number{
			return (Math.atan2(col1.y, col1.x));
		}
		public function Solve(out:b2Vec2, bX:Number, bY:Number):b2Vec2{
			var a11:Number = col1.x;
			var a12:Number = col2.x;
			var a21:Number = col1.y;
			var a22:Number = col2.y;
			var det:Number = ((a11 * a22) - (a12 * a21));
			det = (1 / det);
			out.x = (det * ((a22 * bX) - (a12 * bY)));
			out.y = (det * ((a11 * bY) - (a21 * bX)));
			return (out);
		}

	}
}//package Box2D.Common.Math 
Section 38
//b2Math (Box2D.Common.Math.b2Math)
package Box2D.Common.Math {

	public class b2Math {

		public static const b2Mat22_identity:b2Mat22 = new b2Mat22(0, new b2Vec2(1, 0), new b2Vec2(0, 1));
		public static const b2XForm_identity:b2XForm = new b2XForm(b2Vec2_zero, b2Mat22_identity);
		public static const b2Vec2_zero:b2Vec2 = new b2Vec2(0, 0);

		public function b2Math(){
			super();
		}
		public static function b2CrossVF(a:b2Vec2, s:Number):b2Vec2{
			var v:b2Vec2 = new b2Vec2((s * a.y), (-(s) * a.x));
			return (v);
		}
		public static function AddVV(a:b2Vec2, b:b2Vec2):b2Vec2{
			var v:b2Vec2 = new b2Vec2((a.x + b.x), (a.y + b.y));
			return (v);
		}
		public static function b2IsValid(x:Number):Boolean{
			return (isFinite(x));
		}
		public static function b2MinV(a:b2Vec2, b:b2Vec2):b2Vec2{
			var c:b2Vec2 = new b2Vec2(b2Min(a.x, b.x), b2Min(a.y, b.y));
			return (c);
		}
		public static function b2MulX(T:b2XForm, v:b2Vec2):b2Vec2{
			var a:b2Vec2;
			a = b2MulMV(T.R, v);
			a.x = (a.x + T.position.x);
			a.y = (a.y + T.position.y);
			return (a);
		}
		public static function b2DistanceSquared(a:b2Vec2, b:b2Vec2):Number{
			var cX:Number = (a.x - b.x);
			var cY:Number = (a.y - b.y);
			return (((cX * cX) + (cY * cY)));
		}
		public static function b2Swap(a:Array, b:Array):void{
			var tmp:* = a[0];
			a[0] = b[0];
			b[0] = tmp;
		}
		public static function b2AbsM(A:b2Mat22):b2Mat22{
			var B:b2Mat22 = new b2Mat22(0, b2AbsV(A.col1), b2AbsV(A.col2));
			return (B);
		}
		public static function SubtractVV(a:b2Vec2, b:b2Vec2):b2Vec2{
			var v:b2Vec2 = new b2Vec2((a.x - b.x), (a.y - b.y));
			return (v);
		}
		public static function b2MulXT(T:b2XForm, v:b2Vec2):b2Vec2{
			var a:b2Vec2;
			var tX:Number;
			a = SubtractVV(v, T.position);
			tX = ((a.x * T.R.col1.x) + (a.y * T.R.col1.y));
			a.y = ((a.x * T.R.col2.x) + (a.y * T.R.col2.y));
			a.x = tX;
			return (a);
		}
		public static function b2Abs(a:Number):Number{
			return (((a > 0)) ? a : -(a));
		}
		public static function b2Clamp(a:Number, low:Number, high:Number):Number{
			return (b2Max(low, b2Min(a, high)));
		}
		public static function b2AbsV(a:b2Vec2):b2Vec2{
			var b:b2Vec2 = new b2Vec2(b2Abs(a.x), b2Abs(a.y));
			return (b);
		}
		public static function MulFV(s:Number, a:b2Vec2):b2Vec2{
			var v:b2Vec2 = new b2Vec2((s * a.x), (s * a.y));
			return (v);
		}
		public static function b2CrossVV(a:b2Vec2, b:b2Vec2):Number{
			return (((a.x * b.y) - (a.y * b.x)));
		}
		public static function b2Dot(a:b2Vec2, b:b2Vec2):Number{
			return (((a.x * b.x) + (a.y * b.y)));
		}
		public static function b2CrossFV(s:Number, a:b2Vec2):b2Vec2{
			var v:b2Vec2 = new b2Vec2((-(s) * a.y), (s * a.x));
			return (v);
		}
		public static function AddMM(A:b2Mat22, B:b2Mat22):b2Mat22{
			var C:b2Mat22 = new b2Mat22(0, AddVV(A.col1, B.col1), AddVV(A.col2, B.col2));
			return (C);
		}
		public static function b2Distance(a:b2Vec2, b:b2Vec2):Number{
			var cX:Number = (a.x - b.x);
			var cY:Number = (a.y - b.y);
			return (Math.sqrt(((cX * cX) + (cY * cY))));
		}
		public static function b2MulTMM(A:b2Mat22, B:b2Mat22):b2Mat22{
			var c1:b2Vec2 = new b2Vec2(b2Dot(A.col1, B.col1), b2Dot(A.col2, B.col1));
			var c2:b2Vec2 = new b2Vec2(b2Dot(A.col1, B.col2), b2Dot(A.col2, B.col2));
			var C:b2Mat22 = new b2Mat22(0, c1, c2);
			return (C);
		}
		public static function b2MaxV(a:b2Vec2, b:b2Vec2):b2Vec2{
			var c:b2Vec2 = new b2Vec2(b2Max(a.x, b.x), b2Max(a.y, b.y));
			return (c);
		}
		public static function b2IsPowerOfTwo(x:uint):Boolean{
			var result:Boolean = (((x > 0)) && (((x & (x - 1)) == 0)));
			return (result);
		}
		public static function b2ClampV(a:b2Vec2, low:b2Vec2, high:b2Vec2):b2Vec2{
			return (b2MaxV(low, b2MinV(a, high)));
		}
		public static function b2RandomRange(lo:Number, hi:Number):Number{
			var r:Number = Math.random();
			r = (((hi - lo) * r) + lo);
			return (r);
		}
		public static function b2MulTMV(A:b2Mat22, v:b2Vec2):b2Vec2{
			var u:b2Vec2 = new b2Vec2(b2Dot(v, A.col1), b2Dot(v, A.col2));
			return (u);
		}
		public static function b2Min(a:Number, b:Number):Number{
			return (((a < b)) ? a : b);
		}
		public static function b2Random():Number{
			return (((Math.random() * 2) - 1));
		}
		public static function b2MulMM(A:b2Mat22, B:b2Mat22):b2Mat22{
			var C:b2Mat22 = new b2Mat22(0, b2MulMV(A, B.col1), b2MulMV(A, B.col2));
			return (C);
		}
		public static function b2NextPowerOfTwo(x:uint):uint{
			x = (x | ((x >> 1) & 2147483647));
			x = (x | ((x >> 2) & 1073741823));
			x = (x | ((x >> 4) & 268435455));
			x = (x | ((x >> 8) & 0xFFFFFF));
			x = (x | ((x >> 16) & 0xFFFF));
			return ((x + 1));
		}
		public static function b2Max(a:Number, b:Number):Number{
			return (((a > b)) ? a : b);
		}
		public static function b2MulMV(A:b2Mat22, v:b2Vec2):b2Vec2{
			var u:b2Vec2 = new b2Vec2(((A.col1.x * v.x) + (A.col2.x * v.y)), ((A.col1.y * v.x) + (A.col2.y * v.y)));
			return (u);
		}

	}
}//package Box2D.Common.Math 
Section 39
//b2Sweep (Box2D.Common.Math.b2Sweep)
package Box2D.Common.Math {

	public class b2Sweep {

		public var localCenter:b2Vec2;
		public var a:Number;
		public var c:b2Vec2;
		public var a0:Number;
		public var c0:b2Vec2;
		public var t0:Number;

		public function b2Sweep(){
			localCenter = new b2Vec2();
			c0 = new b2Vec2();
			c = new b2Vec2();
			super();
		}
		public function Advance(t:Number):void{
			var alpha:Number;
			if ((((t0 < t)) && (((1 - t0) > Number.MIN_VALUE)))){
				alpha = ((t - t0) / (1 - t0));
				c0.x = (((1 - alpha) * c0.x) + (alpha * c.x));
				c0.y = (((1 - alpha) * c0.y) + (alpha * c.y));
				a0 = (((1 - alpha) * a0) + (alpha * a));
				t0 = t;
			};
		}
		public function GetXForm(xf:b2XForm, t:Number):void{
			var alpha:Number;
			var angle:Number;
			if ((1 - t0) > Number.MIN_VALUE){
				alpha = ((t - t0) / (1 - t0));
				xf.position.x = (((1 - alpha) * c0.x) + (alpha * c.x));
				xf.position.y = (((1 - alpha) * c0.y) + (alpha * c.y));
				angle = (((1 - alpha) * a0) + (alpha * a));
				xf.R.Set(angle);
			} else {
				xf.position.SetV(c);
				xf.R.Set(a);
			};
			var tMat:b2Mat22 = xf.R;
			xf.position.x = (xf.position.x - ((tMat.col1.x * localCenter.x) + (tMat.col2.x * localCenter.y)));
			xf.position.y = (xf.position.y - ((tMat.col1.y * localCenter.x) + (tMat.col2.y * localCenter.y)));
		}

	}
}//package Box2D.Common.Math 
Section 40
//b2Vec2 (Box2D.Common.Math.b2Vec2)
package Box2D.Common.Math {

	public class b2Vec2 {

		public var y:Number;
		public var x:Number;

		public function b2Vec2(x_:Number=0, y_:Number=0):void{
			super();
			x = x_;
			y = y_;
		}
		public function Add(v:b2Vec2):void{
			x = (x + v.x);
			y = (y + v.y);
		}
		public function Set(x_:Number=0, y_:Number=0):void{
			x = x_;
			y = y_;
		}
		public function Multiply(a:Number):void{
			x = (x * a);
			y = (y * a);
		}
		public function Length():Number{
			return (Math.sqrt(((x * x) + (y * y))));
		}
		public function LengthSquared():Number{
			return (((x * x) + (y * y)));
		}
		public function MulM(A:b2Mat22):void{
			var tX:Number = x;
			x = ((A.col1.x * tX) + (A.col2.x * y));
			y = ((A.col1.y * tX) + (A.col2.y * y));
		}
		public function SetZero():void{
			x = 0;
			y = 0;
		}
		public function MinV(b:b2Vec2):void{
			x = ((x < b.x)) ? x : b.x;
			y = ((y < b.y)) ? y : b.y;
		}
		public function Normalize():Number{
			var length:Number = Math.sqrt(((x * x) + (y * y)));
			if (length < Number.MIN_VALUE){
				return (0);
			};
			var invLength:Number = (1 / length);
			x = (x * invLength);
			y = (y * invLength);
			return (length);
		}
		public function CrossVF(s:Number):void{
			var tX:Number = x;
			x = (s * y);
			y = (-(s) * tX);
		}
		public function MaxV(b:b2Vec2):void{
			x = ((x > b.x)) ? x : b.x;
			y = ((y > b.y)) ? y : b.y;
		}
		public function SetV(v:b2Vec2):void{
			x = v.x;
			y = v.y;
		}
		public function Negative():b2Vec2{
			return (new b2Vec2(-(x), -(y)));
		}
		public function CrossFV(s:Number):void{
			var tX:Number = x;
			x = (-(s) * y);
			y = (s * tX);
		}
		public function Abs():void{
			if (x < 0){
				x = -(x);
			};
			if (y < 0){
				y = -(y);
			};
		}
		public function Subtract(v:b2Vec2):void{
			x = (x - v.x);
			y = (y - v.y);
		}
		public function Copy():b2Vec2{
			return (new b2Vec2(x, y));
		}
		public function MulTM(A:b2Mat22):void{
			var tX:Number = b2Math.b2Dot(this, A.col1);
			y = b2Math.b2Dot(this, A.col2);
			x = tX;
		}
		public function IsValid():Boolean{
			return (((b2Math.b2IsValid(x)) && (b2Math.b2IsValid(y))));
		}

		public static function Make(x_:Number, y_:Number):b2Vec2{
			return (new b2Vec2(x_, y_));
		}

	}
}//package Box2D.Common.Math 
Section 41
//b2XForm (Box2D.Common.Math.b2XForm)
package Box2D.Common.Math {

	public class b2XForm {

		public var position:b2Vec2;
		public var R:b2Mat22;

		public function b2XForm(pos:b2Vec2=null, r:b2Mat22=null):void{
			position = new b2Vec2();
			R = new b2Mat22();
			super();
			if (pos){
				position.SetV(pos);
				R.SetM(r);
			};
		}
		public function Initialize(pos:b2Vec2, r:b2Mat22):void{
			position.SetV(pos);
			R.SetM(r);
		}
		public function Set(x:b2XForm):void{
			position.SetV(x.position);
			R.SetM(x.R);
		}
		public function SetIdentity():void{
			position.SetZero();
			R.SetIdentity();
		}

	}
}//package Box2D.Common.Math 
Section 42
//b2Color (Box2D.Common.b2Color)
package Box2D.Common {
	import Box2D.Common.Math.*;

	public class b2Color {

		private var _r:uint;// = 0
		private var _g:uint;// = 0
		private var _b:uint;// = 0

		public function b2Color(rr:Number, gg:Number, bb:Number){
			super();
			_r = uint((0xFF * b2Math.b2Clamp(rr, 0, 1)));
			_g = uint((0xFF * b2Math.b2Clamp(gg, 0, 1)));
			_b = uint((0xFF * b2Math.b2Clamp(bb, 0, 1)));
		}
		public function Set(rr:Number, gg:Number, bb:Number):void{
			_r = uint((0xFF * b2Math.b2Clamp(rr, 0, 1)));
			_g = uint((0xFF * b2Math.b2Clamp(gg, 0, 1)));
			_b = uint((0xFF * b2Math.b2Clamp(bb, 0, 1)));
		}
		public function set b(bb:Number):void{
			_b = uint((0xFF * b2Math.b2Clamp(bb, 0, 1)));
		}
		public function get color():uint{
			return (((_r | (_g << 8)) | (_b << 16)));
		}
		public function set r(rr:Number):void{
			_r = uint((0xFF * b2Math.b2Clamp(rr, 0, 1)));
		}
		public function set g(gg:Number):void{
			_g = uint((0xFF * b2Math.b2Clamp(gg, 0, 1)));
		}

	}
}//package Box2D.Common 
Section 43
//b2Settings (Box2D.Common.b2Settings)
package Box2D.Common {
	import Box2D.Common.Math.*;

	public class b2Settings {

		public static const b2_angularSleepTolerance:Number = 0.0111111111111111;
		public static const b2_linearSleepTolerance:Number = 0.01;
		public static const b2_angularSlop:Number = 0.0349065850398866;
		public static const b2_linearSlop:Number = 0.005;
		public static const b2_pi:Number = 3.14159265358979;
		public static const b2_maxProxies:int = 0x0200;
		public static const b2_maxAngularVelocitySquared:Number = 62500;
		public static const b2_maxPolygonVertices:int = 16;
		public static const b2_velocityThreshold:Number = 1;
		public static const b2_contactBaumgarte:Number = 0.2;
		public static const b2_maxPairs:int = 4096;
		public static const b2_maxTOIContactsPerIsland:int = 32;
		public static const b2_timeToSleep:Number = 0.5;
		public static const b2_maxManifoldPoints:int = 2;
		public static const b2_maxAngularVelocity:Number = 250;
		public static const b2_maxAngularCorrection:Number = 0.139626340159546;
		public static const USHRT_MAX:int = 0xFFFF;
		public static const b2_maxLinearVelocity:Number = 200;
		public static const b2_maxLinearCorrection:Number = 0.2;
		public static const b2_toiSlop:Number = 0.04;
		public static const b2_maxLinearVelocitySquared:Number = 40000;

		public function b2Settings(){
			super();
		}
		public static function b2Assert(a:Boolean):void{
			var nullVec:b2Vec2;
			if (!a){
				nullVec.x++;
			};
		}

	}
}//package Box2D.Common 
Section 44
//b2CircleContact (Box2D.Dynamics.Contacts.b2CircleContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2CircleContact extends b2Contact {

		private var m_manifolds:Array;
		public var m_manifold:b2Manifold;
		private var m0:b2Manifold;

		private static const s_evalCP:b2ContactPoint = new b2ContactPoint();

		public function b2CircleContact(shape1:b2Shape, shape2:b2Shape){
			m_manifolds = [new b2Manifold()];
			m0 = new b2Manifold();
			super(shape1, shape2);
			m_manifold = m_manifolds[0];
			m_manifold.pointCount = 0;
			var point:b2ManifoldPoint = m_manifold.points[0];
			point.normalImpulse = 0;
			point.tangentImpulse = 0;
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var v1:b2Vec2;
			var v2:b2Vec2;
			var mp0:b2ManifoldPoint;
			var mp:b2ManifoldPoint;
			var b1:b2Body = m_shape1.m_body;
			var b2:b2Body = m_shape2.m_body;
			m0.Set(m_manifold);
			b2Collision.b2CollideCircles(m_manifold, (m_shape1 as b2CircleShape), b1.m_xf, (m_shape2 as b2CircleShape), b2.m_xf);
			var cp:b2ContactPoint = s_evalCP;
			cp.shape1 = m_shape1;
			cp.shape2 = m_shape2;
			cp.friction = m_friction;
			cp.restitution = m_restitution;
			if (m_manifold.pointCount > 0){
				m_manifoldCount = 1;
				mp = m_manifold.points[0];
				if (m0.pointCount == 0){
					mp.normalImpulse = 0;
					mp.tangentImpulse = 0;
					if (listener){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = mp.id._key;
						listener.Add(cp);
					};
				} else {
					mp0 = m0.points[0];
					mp.normalImpulse = mp0.normalImpulse;
					mp.tangentImpulse = mp0.tangentImpulse;
					if (listener){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = mp.id._key;
						listener.Persist(cp);
					};
				};
			} else {
				m_manifoldCount = 0;
				if ((((m0.pointCount > 0)) && (listener))){
					mp0 = m0.points[0];
					cp.position = b1.GetWorldPoint(mp0.localPoint1);
					v1 = b1.GetLinearVelocityFromLocalPoint(mp0.localPoint1);
					v2 = b2.GetLinearVelocityFromLocalPoint(mp0.localPoint2);
					cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
					cp.normal.SetV(m0.normal);
					cp.separation = mp0.separation;
					cp.id.key = mp0.id._key;
					listener.Remove(cp);
				};
			};
		}
		override public function GetManifolds():Array{
			return (m_manifolds);
		}

		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2CircleContact(shape1, shape2));
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 45
//b2ConcaveArcAndCircleContact (Box2D.Dynamics.Contacts.b2ConcaveArcAndCircleContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2ConcaveArcAndCircleContact extends b2PolyAndCircleContact {

		private static var s_evalCP:b2ContactPoint = new b2ContactPoint();

		public function b2ConcaveArcAndCircleContact(shape1:b2Shape, shape2:b2Shape){
			super(shape1, shape2);
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var i:int;
			var v1:b2Vec2;
			var v2:b2Vec2;
			var mp0:b2ManifoldPoint;
			var mp:b2ManifoldPoint;
			var found:Boolean;
			var idKey:uint;
			var j:int;
			var b1:b2Body = m_shape1.m_body;
			var b2:b2Body = m_shape2.m_body;
			m0.Set(m_manifolds[0]);
			m_manifoldCount = b2CollideConcaveArcAndCircle(m_manifolds, (m_shape1 as b2ConcaveArcShape), b1.m_xf, (m_shape2 as b2CircleShape), b2.m_xf);
			var persisted:Array = [false, false];
			var cp:b2ContactPoint = s_evalCP;
			cp.shape1 = m_shape1;
			cp.shape2 = m_shape2;
			cp.friction = m_friction;
			cp.restitution = m_restitution;
			if (m_manifold.pointCount > 0){
				i = 0;
				while (i < m_manifold.pointCount) {
					mp = m_manifold.points[i];
					mp.normalImpulse = 0;
					mp.tangentImpulse = 0;
					found = false;
					idKey = mp.id._key;
					j = 0;
					while (j < m0.pointCount) {
						if (persisted[j] == true){
						} else {
							mp0 = m0.points[j];
							if (mp0.id._key == idKey){
								persisted[j] = true;
								mp.normalImpulse = mp0.normalImpulse;
								mp.tangentImpulse = mp0.tangentImpulse;
								found = true;
								if (listener != null){
									cp.position = b1.GetWorldPoint(mp.localPoint1);
									v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
									v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
									cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
									cp.normal.SetV(m_manifold.normal);
									cp.separation = mp.separation;
									cp.id.key = idKey;
									listener.Persist(cp);
								};
								break;
							};
						};
						j++;
					};
					if ((((found == false)) && (!((listener == null))))){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = idKey;
						listener.Add(cp);
					};
					i++;
				};
				m_manifoldCount = 1;
			} else {
				m_manifoldCount = 0;
			};
			if (listener == null){
				return;
			};
			i = 0;
			while (i < m0.pointCount) {
				if (persisted[i]){
				} else {
					mp0 = m0.points[i];
					cp.position = b1.GetWorldPoint(mp0.localPoint1);
					v1 = b1.GetLinearVelocityFromLocalPoint(mp0.localPoint1);
					v2 = b2.GetLinearVelocityFromLocalPoint(mp0.localPoint2);
					cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
					cp.normal.SetV(m0.normal);
					cp.separation = mp0.separation;
					cp.id.key = mp0.id._key;
					listener.Remove(cp);
				};
				i++;
			};
		}
		override public function GetManifolds():Array{
			return (m_manifolds);
		}

		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2ConcaveArcAndCircleContact(shape1, shape2));
		}
		public static function b2CollideConcaveArcAndCircle(manifolds:Array, polygon:b2ConcaveArcShape, xf1:b2XForm, circle:b2CircleShape, xf2:b2XForm):Number{
			var b2_nullFeature:uint;
			var manifold:b2Manifold;
			var tPoint:b2ManifoldPoint;
			var dX:Number;
			var dY:Number;
			var tVec:b2Vec2;
			var tMat:b2Mat22;
			var positionX:Number;
			var positionY:Number;
			var cX:Number;
			var cY:Number;
			var dist:Number;
			var pX:Number;
			var pY:Number;
			var s:Number;
			var c2X:Number;
			var c2Y:Number;
			var c2:Number;
			var d2:Number;
			var d:Number;
			var norm:Number;
			var u:Number;
			var conservative:Boolean;
			b2_nullFeature = b2Collision.b2_nullFeature;
			manifold = manifolds[0];
			var manifoldCount:Number = 0;
			manifold.pointCount = 0;
			tMat = xf2.R;
			tVec = circle.m_localPosition;
			cX = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			cY = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			dX = (cX - xf1.position.x);
			dY = (cY - xf1.position.y);
			tMat = xf1.R;
			var cLocalX:Number = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			var cLocalY:Number = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			var normalIndex:int;
			var separation:Number = -(Number.MAX_VALUE);
			var radius:Number = circle.m_radius;
			var i = 1;
			while (i < polygon.m_vertexCount) {
				dX = (cLocalX - polygon.m_vertices[i].x);
				dY = (cLocalY - polygon.m_vertices[i].y);
				s = ((polygon.m_normals[i].x * dX) + (polygon.m_normals[i].y * dY));
				if (s > radius){
					manifoldCount = 0;
					return (manifoldCount);
				};
				if (s > separation){
					separation = s;
					normalIndex = i;
				};
				i++;
			};
			if (((((true) || ((normalIndex == 1)))) || ((normalIndex == (polygon.m_vertexCount - 1))))){
				s = ((polygon.m_normals[0].x * (cLocalX - polygon.m_vertices[0].x)) + (polygon.m_normals[0].y * (cLocalY - polygon.m_vertices[0].y)));
				c2X = (cLocalX - polygon.m_arcCenter.x);
				c2Y = (cLocalY - polygon.m_arcCenter.y);
				c2 = Math.sqrt(((c2X * c2X) + (c2Y * c2Y)));
				c2X = (c2X / c2);
				c2Y = (c2Y / c2);
				s = Math.max(s, (polygon.m_radius - c2));
				if (s > radius){
					manifoldCount = 0;
					return (manifoldCount);
				};
				if (s > separation){
					separation = s;
					normalIndex = 0;
				};
			};
			if ((((normalIndex == 0)) && ((radius >= polygon.m_radius)))){
				if (manifolds.length < 2){
					manifolds[1] = new b2Manifold();
					manifolds[1].pointCount = 0;
					manifolds[1].points[0].normalImpulse = 0;
					manifolds[1].points[0].tangentImpulse = 0;
				};
				manifoldCount = 0;
				i = 0;
				while (i < 2) {
					dX = (polygon.m_vertices[i].x - cLocalX);
					dY = (polygon.m_vertices[i].y - cLocalY);
					d2 = ((dX * dX) + (dY * dY));
					if (d2 < (radius * radius)){
						d = Math.sqrt(d2);
						manifolds[manifoldCount].pointCount = 1;
						tPoint = manifolds[manifoldCount].points[0];
						tPoint.id.features.incidentEdge = b2_nullFeature;
						tPoint.id.features.incidentVertex = i;
						tPoint.id.features.referenceEdge = b2_nullFeature;
						tPoint.id.features.flip = 0;
						tPoint.separation = (d - radius);
						tPoint.normalImpulse = 0;
						tPoint.tangentImpulse = 0;
						dX = (-(dX) / d);
						dY = (-(dY) / d);
						manifolds[manifoldCount].normal.x = ((tMat.col1.x * dX) + (tMat.col2.x * dY));
						manifolds[manifoldCount].normal.y = ((tMat.col1.y * dX) + (tMat.col2.y * dY));
						positionX = (cX - (radius * manifolds[manifoldCount].normal.x));
						positionY = (cY - (radius * manifolds[manifoldCount].normal.y));
						dX = (positionX - xf1.position.x);
						dY = (positionY - xf1.position.y);
						tMat = xf1.R;
						tPoint.localPoint1.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
						tPoint.localPoint1.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
						dX = (positionX - xf2.position.x);
						dY = (positionY - xf2.position.y);
						tMat = xf2.R;
						tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
						tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
						manifoldCount++;
					};
					i++;
				};
				return (manifoldCount);
			};
			if (separation < Number.MIN_VALUE){
				manifold.pointCount = 1;
				manifoldCount = 1;
				if (normalIndex == 0){
					tMat = xf1.R;
					manifold.normal.x = -(((tMat.col1.x * c2X) + (tMat.col2.x * c2Y)));
					manifold.normal.y = -(((tMat.col1.y * c2X) + (tMat.col2.y * c2Y)));
				} else {
					tVec = polygon.m_normals[normalIndex];
					tMat = xf1.R;
					manifold.normal.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
					manifold.normal.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
				};
				tPoint = manifold.points[0];
				tPoint.id.features.incidentEdge = normalIndex;
				tPoint.id.features.incidentVertex = b2_nullFeature;
				tPoint.id.features.referenceEdge = 0;
				tPoint.id.features.flip = 0;
				positionX = (cX - (radius * manifold.normal.x));
				positionY = (cY - (radius * manifold.normal.y));
				dX = (positionX - xf1.position.x);
				dY = (positionY - xf1.position.y);
				tMat = xf1.R;
				tPoint.localPoint1.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				tPoint.localPoint1.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				dX = (positionX - xf2.position.x);
				dY = (positionY - xf2.position.y);
				tMat = xf2.R;
				tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				tPoint.separation = (separation - radius);
				return (manifoldCount);
			};
			var vertIndex1:int = normalIndex;
			var vertIndex2:int = (((vertIndex1 + 1) < polygon.m_vertexCount)) ? (vertIndex1 + 1) : 0;
			var eX:Number = (polygon.m_vertices[vertIndex2].x - polygon.m_vertices[vertIndex1].x);
			var eY:Number = (polygon.m_vertices[vertIndex2].y - polygon.m_vertices[vertIndex1].y);
			var length:Number = Math.sqrt(((eX * eX) + (eY * eY)));
			eX = (eX / length);
			eY = (eY / length);
			if (length < Number.MIN_VALUE){
				dX = (cLocalX - polygon.m_vertices[vertIndex1].x);
				dY = (cLocalY - polygon.m_vertices[vertIndex1].y);
				dist = Math.sqrt(((dX * dX) + (dY * dY)));
				dX = (dX / dist);
				dY = (dY / dist);
				if (dist > radius){
					manifoldCount = 0;
					return (manifoldCount);
				};
				manifold.pointCount = 1;
				manifoldCount = 1;
				tMat = xf1.R;
				manifold.normal.x = ((tMat.col1.x * dX) + (tMat.col2.x * dY));
				manifold.normal.y = ((tMat.col1.y * dX) + (tMat.col2.y * dY));
				tPoint = manifold.points[0];
				tPoint.id.features.incidentEdge = b2_nullFeature;
				tPoint.id.features.incidentVertex = vertIndex1;
				tPoint.id.features.referenceEdge = b2_nullFeature;
				tPoint.id.features.flip = 0;
				positionX = (cX - (radius * manifold.normal.x));
				positionY = (cY - (radius * manifold.normal.y));
				dX = (positionX - xf1.position.x);
				dY = (positionY - xf1.position.y);
				tMat = xf1.R;
				tPoint.localPoint1.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				tPoint.localPoint1.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				dX = (positionX - xf2.position.x);
				dY = (positionY - xf2.position.y);
				tMat = xf2.R;
				tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				tPoint.separation = (dist - radius);
				return (manifoldCount);
			};
			dX = (cLocalX - polygon.m_vertices[vertIndex1].x);
			dY = (cLocalY - polygon.m_vertices[vertIndex1].y);
			tPoint = manifold.points[0];
			tPoint.id.features.incidentEdge = 0;
			tPoint.id.features.incidentVertex = 0;
			tPoint.id.features.referenceEdge = 0;
			tPoint.id.features.flip = 0;
			if (normalIndex == 0){
				norm = ((eX * c2X) + (eY * c2Y));
				if (((c2X * polygon.m_normals[0].x) + (c2Y * polygon.m_normals[0].y)) > 0){
					if (norm < 0){
						pX = polygon.m_vertices[vertIndex1].x;
						pY = polygon.m_vertices[vertIndex1].y;
						tPoint.id.features.incidentVertex = vertIndex1;
						tPoint.id.features.incidentEdge = b2_nullFeature;
					} else {
						pX = polygon.m_vertices[vertIndex2].x;
						pY = polygon.m_vertices[vertIndex2].y;
						tPoint.id.features.incidentVertex = vertIndex2;
						tPoint.id.features.incidentEdge = b2_nullFeature;
					};
				} else {
					if (norm <= -(polygon.m_norm)){
						pX = polygon.m_vertices[vertIndex1].x;
						pY = polygon.m_vertices[vertIndex1].y;
						tPoint.id.features.incidentVertex = vertIndex1;
						tPoint.id.features.incidentEdge = b2_nullFeature;
					} else {
						if (norm >= polygon.m_norm){
							pX = polygon.m_vertices[vertIndex2].x;
							pY = polygon.m_vertices[vertIndex2].y;
							tPoint.id.features.incidentVertex = vertIndex2;
							tPoint.id.features.incidentEdge = b2_nullFeature;
						} else {
							pX = (polygon.m_arcCenter.x + (c2X * polygon.m_radius));
							pY = (polygon.m_arcCenter.y + (c2Y * polygon.m_radius));
							tPoint.id.features.incidentEdge = vertIndex1;
						};
					};
				};
			} else {
				u = ((dX * eX) + (dY * eY));
				if (u <= 0){
					pX = polygon.m_vertices[vertIndex1].x;
					pY = polygon.m_vertices[vertIndex1].y;
					tPoint.id.features.incidentVertex = vertIndex1;
					tPoint.id.features.incidentEdge = b2_nullFeature;
				} else {
					if (u >= length){
						pX = polygon.m_vertices[vertIndex2].x;
						pY = polygon.m_vertices[vertIndex2].y;
						tPoint.id.features.incidentVertex = vertIndex2;
						tPoint.id.features.incidentEdge = b2_nullFeature;
					} else {
						pX = ((eX * u) + polygon.m_vertices[vertIndex1].x);
						pY = ((eY * u) + polygon.m_vertices[vertIndex1].y);
						tPoint.id.features.incidentEdge = vertIndex1;
					};
				};
			};
			dX = (cLocalX - pX);
			dY = (cLocalY - pY);
			dist = Math.sqrt(((dX * dX) + (dY * dY)));
			dX = (dX / dist);
			dY = (dY / dist);
			if (dist > radius){
				manifoldCount = 0;
				return (manifoldCount);
			};
			manifold.pointCount = 1;
			manifoldCount = 1;
			tMat = xf1.R;
			manifold.normal.x = ((tMat.col1.x * dX) + (tMat.col2.x * dY));
			manifold.normal.y = ((tMat.col1.y * dX) + (tMat.col2.y * dY));
			positionX = (cX - (radius * manifold.normal.x));
			positionY = (cY - (radius * manifold.normal.y));
			dX = (positionX - xf1.position.x);
			dY = (positionY - xf1.position.y);
			tMat = xf1.R;
			tPoint.localPoint1.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			tPoint.localPoint1.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			dX = (positionX - xf2.position.x);
			dY = (positionY - xf2.position.y);
			tMat = xf2.R;
			tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			tPoint.separation = (dist - radius);
			return (manifoldCount);
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 46
//b2Contact (Box2D.Dynamics.Contacts.b2Contact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2Contact {

		public var m_shape1:b2Shape;
		public var m_shape2:b2Shape;
		public var m_prev:b2Contact;
		public var m_toi:Number;
		public var m_next:b2Contact;
		public var m_friction:Number;
		public var m_manifoldCount:int;
		public var m_node1:b2ContactEdge;
		public var m_node2:b2ContactEdge;
		public var m_restitution:Number;
		public var m_flags:uint;

		public static var e_toiFlag:uint = 8;
		public static var e_nonSolidFlag:uint = 1;
		public static var e_slowFlag:uint = 2;
		public static var e_islandFlag:uint = 4;
		public static var s_registers:Array;
		public static var s_initialized:Boolean = false;

		public function b2Contact(s1:b2Shape=null, s2:b2Shape=null){
			m_node1 = new b2ContactEdge();
			m_node2 = new b2ContactEdge();
			super();
			m_flags = 0;
			if (((!(s1)) || (!(s2)))){
				m_shape1 = null;
				m_shape2 = null;
				return;
			};
			if (((s1.IsSensor()) || (s2.IsSensor()))){
				m_flags = (m_flags | e_nonSolidFlag);
			};
			m_shape1 = s1;
			m_shape2 = s2;
			m_manifoldCount = 0;
			m_friction = Math.sqrt((m_shape1.m_friction * m_shape2.m_friction));
			m_restitution = b2Math.b2Max(m_shape1.m_restitution, m_shape2.m_restitution);
			m_prev = null;
			m_next = null;
			m_node1.contact = null;
			m_node1.prev = null;
			m_node1.next = null;
			m_node1.other = null;
			m_node2.contact = null;
			m_node2.prev = null;
			m_node2.next = null;
			m_node2.other = null;
		}
		public function IsSolid():Boolean{
			return (((m_flags & e_nonSolidFlag) == 0));
		}
		public function GetShape1():b2Shape{
			return (m_shape1);
		}
		public function GetShape2():b2Shape{
			return (m_shape2);
		}
		public function GetNext():b2Contact{
			return (m_next);
		}
		public function GetManifoldCount():int{
			return (m_manifoldCount);
		}
		public function GetManifolds():Array{
			return (null);
		}
		public function Update(listener:b2ContactListener):void{
			var oldCount:int = m_manifoldCount;
			Evaluate(listener);
			var newCount:int = m_manifoldCount;
			var body1:b2Body = m_shape1.m_body;
			var body2:b2Body = m_shape2.m_body;
			if ((((newCount == 0)) && ((oldCount > 0)))){
				body1.WakeUp();
				body2.WakeUp();
			};
			if (((((((body1.IsStatic()) || (body1.IsBullet()))) || (body2.IsStatic()))) || (body2.IsBullet()))){
				m_flags = (m_flags & ~(e_slowFlag));
			} else {
				m_flags = (m_flags | e_slowFlag);
			};
		}
		public function Evaluate(listener:b2ContactListener):void{
		}

		public static function InitializeRegisters():void{
			var j:int;
			s_registers = new Array(b2Shape.e_shapeTypeCount);
			var i:int;
			while (i < b2Shape.e_shapeTypeCount) {
				s_registers[i] = new Array(b2Shape.e_shapeTypeCount);
				j = 0;
				while (j < b2Shape.e_shapeTypeCount) {
					s_registers[i][j] = new b2ContactRegister();
					j++;
				};
				i++;
			};
			AddType(b2CircleContact.Create, b2CircleContact.Destroy, b2Shape.e_circleShape, b2Shape.e_circleShape);
			AddType(b2PolyAndCircleContact.Create, b2PolyAndCircleContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_circleShape);
			AddType(b2PolygonContact.Create, b2PolygonContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_polygonShape);
			AddType(b2ConcaveArcAndCircleContact.Create, b2ConcaveArcAndCircleContact.Destroy, b2Shape.e_concaveArcShape, b2Shape.e_circleShape);
			AddType(b2PolyAndConcaveArcContact.Create, b2PolyAndConcaveArcContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_concaveArcShape);
			AddType(b2StaticEdgeAndCircleContact.Create, b2StaticEdgeAndCircleContact.Destroy, b2Shape.e_staticEdgeShape, b2Shape.e_circleShape);
			AddType(b2PolyAndStaticEdgeContact.Create, b2PolyAndStaticEdgeContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_staticEdgeShape);
		}
		public static function Destroy(contact:b2Contact, allocator):void{
			if (contact.m_manifoldCount > 0){
				contact.m_shape1.m_body.WakeUp();
				contact.m_shape2.m_body.WakeUp();
			};
			var type1:int = contact.m_shape1.m_type;
			var type2:int = contact.m_shape2.m_type;
			var reg:b2ContactRegister = s_registers[type1][type2];
			var destroyFcn:Function = reg.destroyFcn;
			destroyFcn(contact, allocator);
		}
		public static function AddType(createFcn:Function, destroyFcn:Function, type1:int, type2:int):void{
			s_registers[type1][type2].createFcn = createFcn;
			s_registers[type1][type2].destroyFcn = destroyFcn;
			s_registers[type1][type2].primary = true;
			if (type1 != type2){
				s_registers[type2][type1].createFcn = createFcn;
				s_registers[type2][type1].destroyFcn = destroyFcn;
				s_registers[type2][type1].primary = false;
			};
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			var c:b2Contact;
			var i:int;
			var m:b2Manifold;
			if (s_initialized == false){
				InitializeRegisters();
				s_initialized = true;
			};
			var type1:int = shape1.m_type;
			var type2:int = shape2.m_type;
			var reg:b2ContactRegister = s_registers[type1][type2];
			var createFcn:Function = reg.createFcn;
			if (createFcn != null){
				if (reg.primary){
					return (createFcn(shape1, shape2, allocator));
				};
				c = createFcn(shape2, shape1, allocator);
				i = 0;
				while (i < c.m_manifoldCount) {
					m = c.GetManifolds()[i];
					m.normal = m.normal.Negative();
					i++;
				};
				return (c);
				//unresolved jump
			};
			return (null);
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 47
//b2ContactConstraint (Box2D.Dynamics.Contacts.b2ContactConstraint)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2ContactConstraint {

		public var points:Array;
		public var normal:b2Vec2;
		public var restitution:Number;
		public var body1:b2Body;
		public var manifold:b2Manifold;
		public var body2:b2Body;
		public var friction:Number;
		public var pointCount:int;

		public function b2ContactConstraint(){
			normal = new b2Vec2();
			super();
			points = new Array(b2Settings.b2_maxManifoldPoints);
			var i:int;
			while (i < b2Settings.b2_maxManifoldPoints) {
				points[i] = new b2ContactConstraintPoint();
				i++;
			};
		}
	}
}//package Box2D.Dynamics.Contacts 
Section 48
//b2ContactConstraintPoint (Box2D.Dynamics.Contacts.b2ContactConstraintPoint)
package Box2D.Dynamics.Contacts {
	import Box2D.Common.Math.*;

	public class b2ContactConstraintPoint {

		public var r2:b2Vec2;
		public var separation:Number;
		public var positionImpulse:Number;
		public var normalImpulse:Number;
		public var tangentMass:Number;
		public var equalizedMass:Number;
		public var tangentImpulse:Number;
		public var localAnchor1:b2Vec2;
		public var localAnchor2:b2Vec2;
		public var normalMass:Number;
		public var velocityBias:Number;
		public var r1:b2Vec2;

		public function b2ContactConstraintPoint(){
			localAnchor1 = new b2Vec2();
			localAnchor2 = new b2Vec2();
			r1 = new b2Vec2();
			r2 = new b2Vec2();
			super();
		}
	}
}//package Box2D.Dynamics.Contacts 
Section 49
//b2ContactEdge (Box2D.Dynamics.Contacts.b2ContactEdge)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;

	public class b2ContactEdge {

		public var other:b2Body;
		public var prev:b2ContactEdge;
		public var contact:b2Contact;
		public var next:b2ContactEdge;

		public function b2ContactEdge(){
			super();
		}
	}
}//package Box2D.Dynamics.Contacts 
Section 50
//b2ContactRegister (Box2D.Dynamics.Contacts.b2ContactRegister)
package Box2D.Dynamics.Contacts {

	public class b2ContactRegister {

		public var primary:Boolean;
		public var createFcn:Function;
		public var destroyFcn:Function;

		public function b2ContactRegister(){
			super();
		}
	}
}//package Box2D.Dynamics.Contacts 
Section 51
//b2ContactResult (Box2D.Dynamics.Contacts.b2ContactResult)
package Box2D.Dynamics.Contacts {
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2ContactResult {

		public var position:b2Vec2;
		public var shape1:b2Shape;
		public var shape2:b2Shape;
		public var normalImpulse:Number;
		public var normal:b2Vec2;
		public var tangentImpulse:Number;
		public var id:b2ContactID;

		public function b2ContactResult(){
			position = new b2Vec2();
			normal = new b2Vec2();
			id = new b2ContactID();
			super();
		}
	}
}//package Box2D.Dynamics.Contacts 
Section 52
//b2ContactSolver (Box2D.Dynamics.Contacts.b2ContactSolver)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2ContactSolver {

		public var m_constraintCount:int;
		public var m_constraints:Array;
		public var m_allocator;
		public var m_step:b2TimeStep;

		public function b2ContactSolver(step:b2TimeStep, contacts:Array, contactCount:int, allocator){
			var contact:b2Contact;
			var i:int;
			var tVec:b2Vec2;
			var tMat:b2Mat22;
			var b1:b2Body;
			var b2:b2Body;
			var manifoldCount:int;
			var manifolds:Array;
			var friction:Number;
			var restitution:Number;
			var v1X:Number;
			var v1Y:Number;
			var v2X:Number;
			var v2Y:Number;
			var w1:Number;
			var w2:Number;
			var j:int;
			var manifold:b2Manifold;
			var normalX:Number;
			var normalY:Number;
			var c:b2ContactConstraint;
			var k:uint;
			var cp:b2ManifoldPoint;
			var ccp:b2ContactConstraintPoint;
			var tX:Number;
			var tY:Number;
			var r1X:Number;
			var r1Y:Number;
			var r2X:Number;
			var r2Y:Number;
			var r1Sqr:Number;
			var r2Sqr:Number;
			var rn1:Number;
			var rn2:Number;
			var kNormal:Number;
			var kEqualized:Number;
			var tangentX:Number;
			var tangentY:Number;
			var rt1:Number;
			var rt2:Number;
			var kTangent:Number;
			var vRel:Number;
			m_step = new b2TimeStep();
			m_constraints = new Array();
			super();
			m_step.dt = step.dt;
			m_step.inv_dt = step.inv_dt;
			m_step.maxIterations = step.maxIterations;
			m_allocator = allocator;
			m_constraintCount = 0;
			i = 0;
			while (i < contactCount) {
				contact = contacts[i];
				m_constraintCount = (m_constraintCount + contact.m_manifoldCount);
				i++;
			};
			i = 0;
			while (i < m_constraintCount) {
				m_constraints[i] = new b2ContactConstraint();
				i++;
			};
			var count:int;
			i = 0;
			while (i < contactCount) {
				contact = contacts[i];
				b1 = contact.m_shape1.m_body;
				b2 = contact.m_shape2.m_body;
				manifoldCount = contact.m_manifoldCount;
				manifolds = contact.GetManifolds();
				friction = contact.m_friction;
				restitution = contact.m_restitution;
				v1X = b1.m_linearVelocity.x;
				v1Y = b1.m_linearVelocity.y;
				v2X = b2.m_linearVelocity.x;
				v2Y = b2.m_linearVelocity.y;
				w1 = b1.m_angularVelocity;
				w2 = b2.m_angularVelocity;
				j = 0;
				while (j < manifoldCount) {
					manifold = manifolds[j];
					normalX = manifold.normal.x;
					normalY = manifold.normal.y;
					c = m_constraints[count];
					c.body1 = b1;
					c.body2 = b2;
					c.manifold = manifold;
					c.normal.x = normalX;
					c.normal.y = normalY;
					c.pointCount = manifold.pointCount;
					c.friction = friction;
					c.restitution = restitution;
					k = 0;
					while (k < c.pointCount) {
						cp = manifold.points[k];
						ccp = c.points[k];
						ccp.normalImpulse = cp.normalImpulse;
						ccp.tangentImpulse = cp.tangentImpulse;
						ccp.separation = cp.separation;
						ccp.positionImpulse = 0;
						ccp.localAnchor1.SetV(cp.localPoint1);
						ccp.localAnchor2.SetV(cp.localPoint2);
						tMat = b1.m_xf.R;
						r1X = (cp.localPoint1.x - b1.m_sweep.localCenter.x);
						r1Y = (cp.localPoint1.y - b1.m_sweep.localCenter.y);
						tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
						r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
						r1X = tX;
						ccp.r1.Set(r1X, r1Y);
						tMat = b2.m_xf.R;
						r2X = (cp.localPoint2.x - b2.m_sweep.localCenter.x);
						r2Y = (cp.localPoint2.y - b2.m_sweep.localCenter.y);
						tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
						r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
						r2X = tX;
						ccp.r2.Set(r2X, r2Y);
						r1Sqr = ((r1X * r1X) + (r1Y * r1Y));
						r2Sqr = ((r2X * r2X) + (r2Y * r2Y));
						rn1 = ((r1X * normalX) + (r1Y * normalY));
						rn2 = ((r2X * normalX) + (r2Y * normalY));
						kNormal = (b1.m_invMass + b2.m_invMass);
						kNormal = (kNormal + ((b1.m_invI * (r1Sqr - (rn1 * rn1))) + (b2.m_invI * (r2Sqr - (rn2 * rn2)))));
						ccp.normalMass = (1 / kNormal);
						kEqualized = ((b1.m_mass * b1.m_invMass) + (b2.m_mass * b2.m_invMass));
						kEqualized = (kEqualized + (((b1.m_mass * b1.m_invI) * (r1Sqr - (rn1 * rn1))) + ((b2.m_mass * b2.m_invI) * (r2Sqr - (rn2 * rn2)))));
						ccp.equalizedMass = (1 / kEqualized);
						tangentX = normalY;
						tangentY = -(normalX);
						rt1 = ((r1X * tangentX) + (r1Y * tangentY));
						rt2 = ((r2X * tangentX) + (r2Y * tangentY));
						kTangent = (b1.m_invMass + b2.m_invMass);
						kTangent = (kTangent + ((b1.m_invI * (r1Sqr - (rt1 * rt1))) + (b2.m_invI * (r2Sqr - (rt2 * rt2)))));
						ccp.tangentMass = (1 / kTangent);
						ccp.velocityBias = 0;
						if (ccp.separation > 0){
							ccp.velocityBias = (-60 * ccp.separation);
						};
						tX = (((v2X + (-(w2) * r2Y)) - v1X) - (-(w1) * r1Y));
						tY = (((v2Y + (w2 * r2X)) - v1Y) - (w1 * r1X));
						vRel = ((c.normal.x * tX) + (c.normal.y * tY));
						if (vRel < -(b2Settings.b2_velocityThreshold)){
							ccp.velocityBias = (ccp.velocityBias + (-(c.restitution) * vRel));
						};
						k++;
					};
					count++;
					j++;
				};
				i++;
			};
		}
		public function InitVelocityConstraints(step:b2TimeStep):void{
			var tVec:b2Vec2;
			var tVec2:b2Vec2;
			var tMat:b2Mat22;
			var c:b2ContactConstraint;
			var b1:b2Body;
			var b2:b2Body;
			var invMass1:Number;
			var invI1:Number;
			var invMass2:Number;
			var invI2:Number;
			var normalX:Number;
			var normalY:Number;
			var tangentX:Number;
			var tangentY:Number;
			var tX:Number;
			var j:int;
			var tCount:int;
			var ccp:b2ContactConstraintPoint;
			var PX:Number;
			var PY:Number;
			var ccp2:b2ContactConstraintPoint;
			var i:int;
			while (i < m_constraintCount) {
				c = m_constraints[i];
				b1 = c.body1;
				b2 = c.body2;
				invMass1 = b1.m_invMass;
				invI1 = b1.m_invI;
				invMass2 = b2.m_invMass;
				invI2 = b2.m_invI;
				normalX = c.normal.x;
				normalY = c.normal.y;
				tangentX = normalY;
				tangentY = -(normalX);
				if (step.warmStarting){
					tCount = c.pointCount;
					j = 0;
					while (j < tCount) {
						ccp = c.points[j];
						ccp.normalImpulse = (ccp.normalImpulse * step.dtRatio);
						ccp.tangentImpulse = (ccp.tangentImpulse * step.dtRatio);
						PX = ((ccp.normalImpulse * normalX) + (ccp.tangentImpulse * tangentX));
						PY = ((ccp.normalImpulse * normalY) + (ccp.tangentImpulse * tangentY));
						b1.m_angularVelocity = (b1.m_angularVelocity - (invI1 * ((ccp.r1.x * PY) - (ccp.r1.y * PX))));
						b1.m_linearVelocity.x = (b1.m_linearVelocity.x - (invMass1 * PX));
						b1.m_linearVelocity.y = (b1.m_linearVelocity.y - (invMass1 * PY));
						b2.m_angularVelocity = (b2.m_angularVelocity + (invI2 * ((ccp.r2.x * PY) - (ccp.r2.y * PX))));
						b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (invMass2 * PX));
						b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (invMass2 * PY));
						j++;
					};
				} else {
					tCount = c.pointCount;
					j = 0;
					while (j < tCount) {
						ccp2 = c.points[j];
						ccp2.normalImpulse = 0;
						ccp2.tangentImpulse = 0;
						j++;
					};
				};
				i++;
			};
		}
		public function SolvePositionConstraints(baumgarte:Number):Boolean{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var c:b2ContactConstraint;
			var b1:b2Body;
			var b2:b2Body;
			var b1_sweep_c:b2Vec2;
			var b1_sweep_a:Number;
			var b2_sweep_c:b2Vec2;
			var b2_sweep_a:Number;
			var invMass1:Number;
			var invI1:Number;
			var invMass2:Number;
			var invI2:Number;
			var normalX:Number;
			var normalY:Number;
			var tCount:int;
			var j:int;
			var ccp:b2ContactConstraintPoint;
			var r1X:Number;
			var r1Y:Number;
			var r2X:Number;
			var r2Y:Number;
			var tX:Number;
			var p1X:Number;
			var p1Y:Number;
			var p2X:Number;
			var p2Y:Number;
			var dpX:Number;
			var dpY:Number;
			var separation:Number;
			var C:Number;
			var dImpulse:Number;
			var impulse0:Number;
			var impulseX:Number;
			var impulseY:Number;
			var minSeparation:Number = 0;
			var i:int;
			while (i < m_constraintCount) {
				c = m_constraints[i];
				b1 = c.body1;
				b2 = c.body2;
				b1_sweep_c = b1.m_sweep.c;
				b1_sweep_a = b1.m_sweep.a;
				b2_sweep_c = b2.m_sweep.c;
				b2_sweep_a = b2.m_sweep.a;
				invMass1 = (b1.m_mass * b1.m_invMass);
				invI1 = (b1.m_mass * b1.m_invI);
				invMass2 = (b2.m_mass * b2.m_invMass);
				invI2 = (b2.m_mass * b2.m_invI);
				normalX = c.normal.x;
				normalY = c.normal.y;
				tCount = c.pointCount;
				j = 0;
				while (j < tCount) {
					ccp = c.points[j];
					tMat = b1.m_xf.R;
					tVec = b1.m_sweep.localCenter;
					r1X = (ccp.localAnchor1.x - tVec.x);
					r1Y = (ccp.localAnchor1.y - tVec.y);
					tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
					r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
					r1X = tX;
					tMat = b2.m_xf.R;
					tVec = b2.m_sweep.localCenter;
					r2X = (ccp.localAnchor2.x - tVec.x);
					r2Y = (ccp.localAnchor2.y - tVec.y);
					tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
					r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
					r2X = tX;
					p1X = (b1_sweep_c.x + r1X);
					p1Y = (b1_sweep_c.y + r1Y);
					p2X = (b2_sweep_c.x + r2X);
					p2Y = (b2_sweep_c.y + r2Y);
					dpX = (p2X - p1X);
					dpY = (p2Y - p1Y);
					separation = (((dpX * normalX) + (dpY * normalY)) + ccp.separation);
					minSeparation = b2Math.b2Min(minSeparation, separation);
					C = (baumgarte * b2Math.b2Clamp((separation + b2Settings.b2_linearSlop), -(b2Settings.b2_maxLinearCorrection), 0));
					dImpulse = (-(ccp.equalizedMass) * C);
					impulse0 = ccp.positionImpulse;
					ccp.positionImpulse = b2Math.b2Max((impulse0 + dImpulse), 0);
					dImpulse = (ccp.positionImpulse - impulse0);
					impulseX = (dImpulse * normalX);
					impulseY = (dImpulse * normalY);
					b1_sweep_c.x = (b1_sweep_c.x - (invMass1 * impulseX));
					b1_sweep_c.y = (b1_sweep_c.y - (invMass1 * impulseY));
					b1_sweep_a = (b1_sweep_a - (invI1 * ((r1X * impulseY) - (r1Y * impulseX))));
					b1.m_sweep.a = b1_sweep_a;
					b1.SynchronizeTransform();
					b2_sweep_c.x = (b2_sweep_c.x + (invMass2 * impulseX));
					b2_sweep_c.y = (b2_sweep_c.y + (invMass2 * impulseY));
					b2_sweep_a = (b2_sweep_a + (invI2 * ((r2X * impulseY) - (r2Y * impulseX))));
					b2.m_sweep.a = b2_sweep_a;
					b2.SynchronizeTransform();
					j++;
				};
				i++;
			};
			return ((minSeparation >= (-1.5 * b2Settings.b2_linearSlop)));
		}
		public function SolveVelocityConstraints():void{
			var j:int;
			var ccp:b2ContactConstraintPoint;
			var r1X:Number;
			var r1Y:Number;
			var r2X:Number;
			var r2Y:Number;
			var dvX:Number;
			var dvY:Number;
			var vn:Number;
			var vt:Number;
			var lambda_n:Number;
			var lambda_t:Number;
			var newImpulse_n:Number;
			var newImpulse_t:Number;
			var PX:Number;
			var PY:Number;
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var c:b2ContactConstraint;
			var b1:b2Body;
			var b2:b2Body;
			var w1:Number;
			var w2:Number;
			var v1:b2Vec2;
			var v2:b2Vec2;
			var invMass1:Number;
			var invI1:Number;
			var invMass2:Number;
			var invI2:Number;
			var normalX:Number;
			var normalY:Number;
			var tangentX:Number;
			var tangentY:Number;
			var friction:Number;
			var tX:Number;
			var tCount:int;
			var maxFriction:Number;
			var i:int;
			while (i < m_constraintCount) {
				c = m_constraints[i];
				b1 = c.body1;
				b2 = c.body2;
				w1 = b1.m_angularVelocity;
				w2 = b2.m_angularVelocity;
				v1 = b1.m_linearVelocity;
				v2 = b2.m_linearVelocity;
				invMass1 = b1.m_invMass;
				invI1 = b1.m_invI;
				invMass2 = b2.m_invMass;
				invI2 = b2.m_invI;
				normalX = c.normal.x;
				normalY = c.normal.y;
				tangentX = normalY;
				tangentY = -(normalX);
				friction = c.friction;
				tCount = c.pointCount;
				j = 0;
				while (j < tCount) {
					ccp = c.points[j];
					dvX = (((v2.x + (-(w2) * ccp.r2.y)) - v1.x) - (-(w1) * ccp.r1.y));
					dvY = (((v2.y + (w2 * ccp.r2.x)) - v1.y) - (w1 * ccp.r1.x));
					vn = ((dvX * normalX) + (dvY * normalY));
					lambda_n = (-(ccp.normalMass) * (vn - ccp.velocityBias));
					vt = ((dvX * tangentX) + (dvY * tangentY));
					lambda_t = (ccp.tangentMass * -(vt));
					newImpulse_n = b2Math.b2Max((ccp.normalImpulse + lambda_n), 0);
					lambda_n = (newImpulse_n - ccp.normalImpulse);
					maxFriction = (friction * ccp.normalImpulse);
					newImpulse_t = b2Math.b2Clamp((ccp.tangentImpulse + lambda_t), -(maxFriction), maxFriction);
					lambda_t = (newImpulse_t - ccp.tangentImpulse);
					PX = ((lambda_n * normalX) + (lambda_t * tangentX));
					PY = ((lambda_n * normalY) + (lambda_t * tangentY));
					v1.x = (v1.x - (invMass1 * PX));
					v1.y = (v1.y - (invMass1 * PY));
					w1 = (w1 - (invI1 * ((ccp.r1.x * PY) - (ccp.r1.y * PX))));
					v2.x = (v2.x + (invMass2 * PX));
					v2.y = (v2.y + (invMass2 * PY));
					w2 = (w2 + (invI2 * ((ccp.r2.x * PY) - (ccp.r2.y * PX))));
					ccp.normalImpulse = newImpulse_n;
					ccp.tangentImpulse = newImpulse_t;
					j++;
				};
				b1.m_angularVelocity = w1;
				b2.m_angularVelocity = w2;
				i++;
			};
		}
		public function FinalizeVelocityConstraints():void{
			var c:b2ContactConstraint;
			var m:b2Manifold;
			var j:int;
			var point1:b2ManifoldPoint;
			var point2:b2ContactConstraintPoint;
			var i:int;
			while (i < m_constraintCount) {
				c = m_constraints[i];
				m = c.manifold;
				j = 0;
				while (j < c.pointCount) {
					point1 = m.points[j];
					point2 = c.points[j];
					point1.normalImpulse = point2.normalImpulse;
					point1.tangentImpulse = point2.tangentImpulse;
					j++;
				};
				i++;
			};
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 53
//b2NullContact (Box2D.Dynamics.Contacts.b2NullContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;

	public class b2NullContact extends b2Contact {

		public function b2NullContact(){
			super();
		}
		override public function Evaluate(l:b2ContactListener):void{
		}
		override public function GetManifolds():Array{
			return (null);
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 54
//b2PolyAndCircleContact (Box2D.Dynamics.Contacts.b2PolyAndCircleContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2PolyAndCircleContact extends b2Contact {

		public var m_manifolds:Array;
		public var m_manifold:b2Manifold;
		public var m0:b2Manifold;

		public static const s_evalCP:b2ContactPoint = new b2ContactPoint();

		public function b2PolyAndCircleContact(shape1:b2Shape, shape2:b2Shape){
			m_manifolds = [new b2Manifold()];
			m0 = new b2Manifold();
			super(shape1, shape2);
			m_manifold = m_manifolds[0];
			b2Settings.b2Assert((m_shape2.m_type == b2Shape.e_circleShape));
			m_manifold.pointCount = 0;
			var point:b2ManifoldPoint = m_manifold.points[0];
			point.normalImpulse = 0;
			point.tangentImpulse = 0;
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var i:int;
			var v1:b2Vec2;
			var v2:b2Vec2;
			var mp0:b2ManifoldPoint;
			var mp:b2ManifoldPoint;
			var found:Boolean;
			var idKey:uint;
			var j:int;
			var b1:b2Body = m_shape1.m_body;
			var b2:b2Body = m_shape2.m_body;
			m0.Set(m_manifold);
			b2Collision.b2CollidePolygonAndCircle(m_manifold, (m_shape1 as b2PolygonShape), b1.m_xf, (m_shape2 as b2CircleShape), b2.m_xf);
			var persisted:Array = [false, false];
			var cp:b2ContactPoint = s_evalCP;
			cp.shape1 = m_shape1;
			cp.shape2 = m_shape2;
			cp.friction = m_friction;
			cp.restitution = m_restitution;
			if (m_manifold.pointCount > 0){
				i = 0;
				while (i < m_manifold.pointCount) {
					mp = m_manifold.points[i];
					mp.normalImpulse = 0;
					mp.tangentImpulse = 0;
					found = false;
					idKey = mp.id._key;
					j = 0;
					while (j < m0.pointCount) {
						if (persisted[j] == true){
						} else {
							mp0 = m0.points[j];
							if (mp0.id._key == idKey){
								persisted[j] = true;
								mp.normalImpulse = mp0.normalImpulse;
								mp.tangentImpulse = mp0.tangentImpulse;
								found = true;
								if (listener != null){
									cp.position = b1.GetWorldPoint(mp.localPoint1);
									v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
									v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
									cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
									cp.normal.SetV(m_manifold.normal);
									cp.separation = mp.separation;
									cp.id.key = idKey;
									listener.Persist(cp);
								};
								break;
							};
						};
						j++;
					};
					if ((((found == false)) && (!((listener == null))))){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = idKey;
						listener.Add(cp);
					};
					i++;
				};
				m_manifoldCount = 1;
			} else {
				m_manifoldCount = 0;
			};
			if (listener == null){
				return;
			};
			i = 0;
			while (i < m0.pointCount) {
				if (persisted[i]){
				} else {
					mp0 = m0.points[i];
					cp.position = b1.GetWorldPoint(mp0.localPoint1);
					v1 = b1.GetLinearVelocityFromLocalPoint(mp0.localPoint1);
					v2 = b2.GetLinearVelocityFromLocalPoint(mp0.localPoint2);
					cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
					cp.normal.SetV(m0.normal);
					cp.separation = mp0.separation;
					cp.id.key = mp0.id._key;
					listener.Remove(cp);
				};
				i++;
			};
		}
		override public function GetManifolds():Array{
			return (m_manifolds);
		}

		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2PolyAndCircleContact(shape1, shape2));
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 55
//b2PolyAndConcaveArcContact (Box2D.Dynamics.Contacts.b2PolyAndConcaveArcContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2PolyAndConcaveArcContact extends b2PolygonContact {

		private var m_arcManifolds:Array;
		private var m_arcColl:Boolean;

		public function b2PolyAndConcaveArcContact(shape1:b2Shape, shape2:b2Shape):void{
			m_arcManifolds = [];
			super(shape1, shape2);
		}
		private function enlargeManifolds(l:Number):void{
			var tMani:b2Manifold;
			while (m_arcManifolds.length < l) {
				tMani = new b2Manifold();
				tMani.pointCount = 0;
				tMani.points[0].normalImpulse = 0;
				tMani.points[0].tangentImpulse = 0;
				m_arcManifolds.push(tMani);
			};
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var b1:b2Body;
			var b2:b2Body;
			var i:int;
			var j:int;
			var tMani:b2Manifold;
			var cp:b2ManifoldPoint;
			var cp0:b2ManifoldPoint;
			var singleKey:Number;
			var poly:b2PolygonShape;
			var arc:b2ConcaveArcShape;
			var localCenter:b2Vec2;
			var local0:b2Vec2;
			var bool1:Boolean;
			var tVec:b2Vec2;
			var topVx:b2Vec2;
			var d2:Number;
			var d:Number;
			var s1:Number;
			var s2:Number;
			var l:Number;
			var direction:Number;
			var currVx:Number;
			var startVx:Number;
			var maxS:Number;
			var maxEdge:Number;
			var local:b2Vec2;
			var s:Number;
			var arcNormal1:b2Vec2;
			var arcNormal2:b2Vec2;
			var polyVx:b2Vec2;
			var polyNormal:b2Vec2;
			var v2x:Number;
			var v2y:Number;
			var polyVx2:b2Vec2;
			var dot1:Number;
			var dot2:Number;
			var tangent:b2Vec2;
			var t1:Number;
			var t2:Number;
			var t3:Number;
			var t4:Number;
			var tPoint:b2ManifoldPoint;
			var tMat:*;
			b1 = m_shape1.m_body;
			b2 = m_shape2.m_body;
			var b2_nullFeature:uint = b2Collision.b2_nullFeature;
			var impulses:Array = [];
			if (!m_arcColl){
				i = 0;
				while (i < m_manifoldCount) {
					j = 0;
					while (j < m_manifolds[i].pointCount) {
						cp0 = m_manifolds[i].points[j];
						cp = new b2ManifoldPoint();
						impulses[cp0.id.key] = cp;
						cp.normalImpulse = cp0.normalImpulse;
						cp.tangentImpulse = cp0.tangentImpulse;
						j++;
					};
					i++;
				};
				if ((((m_manifoldCount == 1)) && ((m_manifolds[0].pointCount == 1)))){
					singleKey = m_manifolds[0].points[0].id.key;
				} else {
					singleKey = -1;
				};
			} else {
				i = 0;
				while (i < m_manifoldCount) {
					j = 0;
					while (j < m_arcManifolds[i].pointCount) {
						cp0 = m_arcManifolds[i].points[j];
						cp = new b2ManifoldPoint();
						impulses[cp0.id.key] = cp;
						cp.normalImpulse = cp0.normalImpulse;
						cp.tangentImpulse = cp0.tangentImpulse;
						j++;
					};
					i++;
				};
				if ((((m_manifoldCount == 1)) && ((m_arcManifolds[0].pointCount == 1)))){
					singleKey = m_arcManifolds[0].points[0].id.key;
				} else {
					singleKey = -1;
				};
			};
			super.Evaluate(listener);
			var polyManiCount:Number = m_manifoldCount;
			if (m_manifoldCount == 0){
				return;
			};
			cp = m_manifolds[0].points[0];
			var features:Features = cp.id.features;
			var edge:Number = (features.flip) ? features.referenceEdge : features.incidentEdge;
			var polySep:Number = -(Number.MAX_VALUE);
			if ((((((m_manifoldCount == 1)) && (!((edge == 0))))) && ((cp.separation < 0)))){
				polySep = cp.separation;
			};
			poly = (m_shape1 as b2PolygonShape);
			arc = (m_shape2 as b2ConcaveArcShape);
			var arcSep:Number = Number.MAX_VALUE;
			localCenter = b2Math.b2MulXT(b1.m_xf, b2Math.b2MulX(b2.m_xf, arc.m_arcCenter));
			local0 = b2Math.b2MulX(b2.m_xf, arc.m_vertices[0]);
			var world0:b2Vec2 = local0.Copy();
			local0 = b2Math.b2MulXT(b1.m_xf, local0);
			var local1:b2Vec2 = b2Math.b2MulX(b2.m_xf, arc.m_vertices[1]);
			var world1:b2Vec2 = local1.Copy();
			local1 = b2Math.b2MulXT(b1.m_xf, local1);
			var localNorm:b2Vec2 = b2Math.b2MulTMV(b1.m_xf.R, b2Math.b2MulMV(b2.m_xf.R, arc.m_normals[0].Copy()));
			var worlds:Array = [world0, world1];
			var locals:Array = [local0, local1];
			var strictMode:Boolean;
			m_manifoldCount = 0;
			var autoApprove:Array = [-1, -1];
			var arcLimitations:Array = [-1, -1];
			if (edge == 0){
				i = 0;
				while (i < 2) {
					maxS = -(Number.MAX_VALUE);
					maxEdge = -1;
					local = locals[i];
					if (i == 0){
						arcNormal1 = b2Math.b2MulTMV(b1.m_xf.R, b2Math.b2MulMV(b2.m_xf.R, arc.m_normals[(arc.m_vertexCount - 1)]));
						arcNormal2 = b2Math.SubtractVV(localCenter, local);
						arcNormal2.Normalize();
					} else {
						arcNormal2 = b2Math.b2MulTMV(b1.m_xf.R, b2Math.b2MulMV(b2.m_xf.R, arc.m_normals[1]));
						arcNormal1 = b2Math.SubtractVV(localCenter, local);
						arcNormal1.Normalize();
					};
					j = 0;
					while (j < poly.m_vertexCount) {
						polyVx = poly.m_vertices[j];
						polyNormal = poly.m_normals[j];
						if (((polyNormal.x * arcNormal1.y) - (polyNormal.y * arcNormal1.x)) < 0){
						} else {
							if (((polyNormal.x * arcNormal2.y) - (polyNormal.y * arcNormal2.x)) > 0){
							} else {
								v2x = (local.x - polyVx.x);
								v2y = (local.y - polyVx.y);
								s = ((v2x * polyNormal.x) + (v2y * polyNormal.y));
								if (s > 0){
									maxEdge = -1;
									break;
								};
								if (s > maxS){
									maxS = s;
									maxEdge = j;
								};
							};
						};
						j++;
					};
					if (maxEdge != -1){
						polyNormal = poly.m_normals[maxEdge];
						polyVx = poly.m_vertices[maxEdge];
						polyVx2 = poly.m_vertices[(((maxEdge + 1) < poly.m_vertexCount)) ? (maxEdge + 1) : 0];
						dot1 = ((polyNormal.x * arcNormal1.x) + (polyNormal.y * arcNormal1.y));
						dot2 = ((polyNormal.x * arcNormal2.x) + (polyNormal.y * arcNormal2.y));
						if (dot1 < dot2){
							tangent = b2Math.b2CrossVF(arcNormal1, 1);
						} else {
							tangent = b2Math.b2CrossVF(arcNormal2, -1);
						};
						t1 = (((local.x - polyVx.x) * polyNormal.x) + ((local.y - polyVx.y) * polyNormal.y));
						t2 = ((tangent.x * polyNormal.x) + (tangent.y * polyNormal.y));
						t3 = (-(t1) / t2);
						v2x = (polyVx2.x - polyVx.x);
						v2y = (polyVx2.y - polyVx.y);
						t4 = ((((local.x + (t3 * tangent.x)) - polyVx.x) * v2x) + (((local.y + (t3 * tangent.y)) - polyVx.y) * v2y));
						if ((((t4 < 0)) || ((t4 > ((v2x * v2x) + (v2y * v2y)))))){
							maxEdge = -1;
						};
					};
					if (maxEdge != -1){
						arcLimitations[i] = maxEdge;
						if (i == 0){
							s = (((polyVx2.x - local.x) * arcNormal2.x) + ((polyVx2.y - local.y) * arcNormal2.y));
							if ((((maxS < s)) && ((s < 0)))){
								autoApprove[i] = (((maxEdge + 1) < poly.m_vertexCount)) ? (maxEdge + 1) : 0;
								maxEdge = -1;
							};
						} else {
							s = (((polyVx.x - local.x) * arcNormal1.x) + ((polyVx.y - local.y) * arcNormal1.y));
							if ((((maxS < s)) && ((s < 0)))){
								autoApprove[i] = maxEdge;
								maxEdge = -1;
							};
						};
					};
					if (maxEdge != -1){
						m_manifoldCount++;
						enlargeManifolds(m_manifoldCount);
						tMani = m_arcManifolds[(m_manifoldCount - 1)];
						tMani.pointCount = 1;
						tPoint = tMani.points[0];
						tPoint.localPoint1.SetV(locals[i]);
						tPoint.localPoint2.SetV(arc.m_vertices[i]);
						tPoint.id.features.incidentEdge = b2_nullFeature;
						tPoint.id.features.incidentVertex = i;
						tPoint.id.features.referenceEdge = maxEdge;
						tPoint.id.features.flip = 0;
						tPoint.separation = maxS;
						tPoint.normalImpulse = 0;
						tPoint.tangentImpulse = 0;
						tMani.normal = b2Math.b2MulMV(b1.m_xf.R, poly.m_normals[maxEdge]);
						arcSep = Math.min(arcSep, tPoint.separation);
					};
					i++;
				};
			};
			if (arcLimitations[1] == -1){
				if (arcLimitations[0] == -1){
					direction = 1;
					startVx = 0;
				} else {
					direction = (poly.m_vertexCount - 1);
					startVx = (((arcLimitations[0] + 1) == poly.m_vertexCount)) ? 0 : (arcLimitations[0] + 1);
				};
			} else {
				direction = 1;
				startVx = arcLimitations[1];
			};
			var foundBlock:Boolean;
			currVx = startVx;
			do  {
				bool1 = true;
				tVec = poly.m_vertices[currVx];
				if (arcLimitations[0] != -1){
					l = arcLimitations[0];
					topVx = poly.m_vertices[(((l + 1) == poly.m_vertexCount)) ? 0 : (l + 1)];
					bool1 = ((bool1) && (((((tVec.x - topVx.x) * poly.m_normals[l].y) - ((tVec.y - topVx.y) * poly.m_normals[l].x)) > 0)));
				};
				if (arcLimitations[1] != -1){
					l = arcLimitations[1];
					topVx = poly.m_vertices[l];
					bool1 = ((bool1) && (((((tVec.x - topVx.x) * poly.m_normals[l].y) - ((tVec.y - topVx.y) * poly.m_normals[l].x)) < 0)));
				};
				if (((foundBlock) && (!(bool1)))){
					startVx = ((currVx + direction) % poly.m_vertexCount);
				};
				if (bool1){
					foundBlock = true;
				};
				tVec = new b2Vec2((poly.m_vertices[currVx].x - localCenter.x), (poly.m_vertices[currVx].y - localCenter.y));
				d2 = ((tVec.x * tVec.x) + (tVec.y * tVec.y));
				d = Math.sqrt(d2);
				s1 = (arc.m_radius - d);
				s2 = (((poly.m_vertices[currVx].x - local0.x) * localNorm.x) + ((poly.m_vertices[currVx].y - local0.y) * localNorm.y));
				s = Math.max(s1, s2);
				arcSep = Math.min(arcSep, s);
				bool1 = ((bool1) && ((s < 0)));
				if (((((bool1) || ((currVx == autoApprove[0])))) || ((currVx == autoApprove[1])))){
					m_manifoldCount++;
					enlargeManifolds(m_manifoldCount);
					tMani = m_arcManifolds[(m_manifoldCount - 1)];
					tMani.pointCount = 1;
					tPoint = tMani.points[0];
					tPoint.id.features.incidentEdge = b2_nullFeature;
					tPoint.id.features.incidentVertex = currVx;
					tPoint.id.features.referenceEdge = 0;
					tPoint.id.features.flip = 0;
					tPoint.normalImpulse = 0;
					tPoint.tangentImpulse = 0;
					tVec.x = (tVec.x / d);
					tVec.y = (tVec.y / d);
					tMat = b1.m_xf.R;
					tMani.normal.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
					tMani.normal.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
					tVec = poly.m_vertices[currVx];
					tPoint.localPoint1.SetV(tVec);
					tPoint.localPoint2.SetV(b2Math.b2MulXT(b2.m_xf, b2Math.b2MulX(b1.m_xf, tVec)));
					tPoint.separation = (arc.m_radius - d);
				};
				currVx = ((currVx + direction) % poly.m_vertexCount);
			} while (currVx != startVx);
			var arcManiCount:int = m_manifoldCount;
			if (polySep > arcSep){
				m_arcColl = false;
				m_manifoldCount = polyManiCount;
				i = 0;
				while (i < m_manifoldCount) {
					j = 0;
					while (j < m_manifolds[i].pointCount) {
						cp = m_manifolds[i].points[j];
						cp0 = impulses[cp.id.key];
						if (cp0){
							cp.normalImpulse = cp0.normalImpulse;
							cp.tangentImpulse = cp0.tangentImpulse;
						};
						j++;
					};
					i++;
				};
				if (((((!((singleKey == -1))) && ((m_manifoldCount == 1)))) && ((m_manifolds[0].pointCount == 1)))){
					cp = m_manifolds[0].points[0];
					cp0 = impulses[singleKey];
					if (cp0){
						cp.normalImpulse = cp0.normalImpulse;
						cp.tangentImpulse = cp0.tangentImpulse;
					};
				};
			} else {
				m_arcColl = true;
				m_manifoldCount = arcManiCount;
				i = 0;
				while (i < m_manifoldCount) {
					j = 0;
					while (j < m_arcManifolds[i].pointCount) {
						cp = m_arcManifolds[i].points[j];
						cp0 = impulses[cp.id.key];
						if (cp0){
							cp.normalImpulse = cp0.normalImpulse;
							cp.tangentImpulse = cp0.tangentImpulse;
						};
						j++;
					};
					i++;
				};
				if (((((!((singleKey == -1))) && ((m_manifoldCount == 1)))) && ((m_arcManifolds[0].pointCount == 1)))){
					cp = m_arcManifolds[0].points[0];
					cp0 = impulses[singleKey];
					if (cp0){
						cp.normalImpulse = cp0.normalImpulse;
						cp.tangentImpulse = cp0.tangentImpulse;
					};
				};
			};
		}
		override public function GetManifolds():Array{
			if (m_arcColl){
				return (m_arcManifolds);
			};
			return (m_manifolds);
		}

		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2PolyAndConcaveArcContact(shape1, shape2));
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 56
//b2PolyAndStaticEdgeContact (Box2D.Dynamics.Contacts.b2PolyAndStaticEdgeContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2PolyAndStaticEdgeContact extends b2Contact {

		public var m_manifolds:Array;
		public var m_manifold:b2Manifold;
		public var m0:b2Manifold;

		public static const s_evalCP:b2ContactPoint = new b2ContactPoint();
		private static const k_slop:Number = 4.94065645841247E-322;

		public function b2PolyAndStaticEdgeContact(shape1:b2Shape, shape2:b2Shape){
			m_manifolds = [new b2Manifold()];
			m0 = new b2Manifold();
			super(shape1, shape2);
			m_manifold = m_manifolds[0];
			m_manifold.pointCount = 0;
			var point:b2ManifoldPoint = m_manifold.points[0];
			point.normalImpulse = 0;
			point.tangentImpulse = 0;
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var i:int;
			var v1:b2Vec2;
			var v2:b2Vec2;
			var mp0:b2ManifoldPoint;
			var mp:b2ManifoldPoint;
			var found:Boolean;
			var idKey:uint;
			var j:int;
			var b1:b2Body = m_shape1.m_body;
			var b2:b2Body = m_shape2.m_body;
			m0.Set(m_manifold);
			b2CollidePolygonAndStaticEdge(m_manifold, (m_shape1 as b2PolygonShape), b1.m_xf, (m_shape2 as b2StaticEdgeShape), b2.m_xf);
			var persisted:Array = [false, false];
			var cp:b2ContactPoint = s_evalCP;
			cp.shape1 = m_shape1;
			cp.shape2 = m_shape2;
			cp.friction = m_friction;
			cp.restitution = m_restitution;
			if (m_manifold.pointCount > 0){
				i = 0;
				while (i < m_manifold.pointCount) {
					mp = m_manifold.points[i];
					mp.normalImpulse = 0;
					mp.tangentImpulse = 0;
					found = false;
					idKey = mp.id._key;
					j = 0;
					while (j < m0.pointCount) {
						if (persisted[j] == true){
						} else {
							mp0 = m0.points[j];
							if (mp0.id._key == idKey){
								persisted[j] = true;
								mp.normalImpulse = mp0.normalImpulse;
								mp.tangentImpulse = mp0.tangentImpulse;
								found = true;
								if (listener != null){
									cp.position = b1.GetWorldPoint(mp.localPoint1);
									v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
									v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
									cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
									cp.normal.SetV(m_manifold.normal);
									cp.separation = mp.separation;
									cp.id.key = idKey;
									listener.Persist(cp);
								};
								break;
							};
						};
						j++;
					};
					if ((((found == false)) && (!((listener == null))))){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = idKey;
						listener.Add(cp);
					};
					i++;
				};
				m_manifoldCount = 1;
			} else {
				m_manifoldCount = 0;
			};
			if (listener == null){
				return;
			};
			i = 0;
			while (i < m0.pointCount) {
				if (persisted[i]){
				} else {
					mp0 = m0.points[i];
					cp.position = b1.GetWorldPoint(mp0.localPoint1);
					v1 = b1.GetLinearVelocityFromLocalPoint(mp0.localPoint1);
					v2 = b2.GetLinearVelocityFromLocalPoint(mp0.localPoint2);
					cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
					cp.normal.SetV(m0.normal);
					cp.separation = mp0.separation;
					cp.id.key = mp0.id._key;
					listener.Remove(cp);
				};
				i++;
			};
		}
		override public function GetManifolds():Array{
			return (m_manifolds);
		}

		public static function b2CollidePolygonAndStaticEdge(manifold:b2Manifold, polygon:b2PolygonShape, xf1:b2XForm, edge:b2StaticEdgeShape, xf2:b2XForm):void{
			var tPoint:b2ManifoldPoint;
			var tVec:b2Vec2;
			var tVec2:b2Vec2;
			var tMat:b2Mat22;
			var dX:Number;
			var dY:Number;
			var separation1:Number;
			var separation2:Number;
			var separationV1:Boolean;
			var separationIndex:int;
			var prevEN:Number;
			var nextEN:Number;
			var enterEN:Number;
			var exitEN:Number;
			var deepestIndex:int;
			var ecx:Number;
			var ecy:Number;
			var edx:Number;
			var edy:Number;
			var ed1:Number;
			var ed2:Number;
			manifold.pointCount = 0;
			tMat = xf1.R;
			dX = (edge.m_v1.x - xf1.position.x);
			dY = (edge.m_v1.y - xf1.position.y);
			var v1x:Number = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			var v1y:Number = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			dX = (edge.m_v2.x - xf1.position.x);
			dY = (edge.m_v2.y - xf1.position.y);
			var v2x:Number = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			var v2y:Number = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			dX = edge.m_normal.x;
			dY = edge.m_normal.y;
			var enx:Number = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			var eny:Number = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
			var separationMax:Number = -(Infinity);
			var vertexCount:int = polygon.m_vertexCount;
			var vertices:Array = polygon.m_vertices;
			var normals:Array = polygon.m_normals;
			var enterStartIndex = -1;
			var enterEndIndex = -1;
			var exitStartIndex = -1;
			var exitEndIndex = -1;
			var deepestEN:Number = Infinity;
			tVec = vertices[(vertexCount - 1)];
			dX = (tVec.x - v1x);
			dY = (tVec.y - v1y);
			prevEN = ((dX * enx) + (dY * eny));
			var i:int;
			while (i < vertexCount) {
				tVec = vertices[i];
				tVec2 = normals[i];
				dX = (v1x - tVec.x);
				dY = (v1y - tVec.y);
				separation1 = ((dX * tVec2.x) + (dY * tVec2.y));
				dX = (v2x - tVec.x);
				dY = (v2y - tVec.y);
				separation2 = ((dX * tVec2.x) + (dY * tVec2.y));
				if (separation2 < separation1){
					if (separation2 > separationMax){
						separationMax = separation2;
						separationV1 = false;
						separationIndex = i;
					};
				} else {
					if (separation1 > separationMax){
						separationMax = separation1;
						separationV1 = true;
						separationIndex = i;
					};
				};
				nextEN = -(((dX * enx) + (dY * eny)));
				if ((((nextEN >= 0)) && ((prevEN < 0)))){
					exitStartIndex = ((i)==0) ? (vertexCount - 1) : (i - 1);
					exitEndIndex = i;
					exitEN = prevEN;
				} else {
					if ((((nextEN < 0)) && ((prevEN >= 0)))){
						enterStartIndex = ((i)==0) ? (vertexCount - 1) : (i - 1);
						enterEndIndex = i;
						enterEN = nextEN;
					};
				};
				if (nextEN < deepestEN){
					deepestEN = nextEN;
					deepestIndex = i;
				};
				prevEN = nextEN;
				i++;
			};
			if (enterStartIndex == -1){
				return;
			};
			if (separationMax > 0){
				return;
			};
			if (separationMax > (deepestEN + b2Settings.b2_linearSlop)){
				tVec2 = normals[separationIndex];
				if (separationV1){
					dX = edge.m_cornerDir1.x;
					dY = edge.m_cornerDir1.y;
					ecx = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
					ecy = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				} else {
					dX = edge.m_cornerDir2.x;
					dY = edge.m_cornerDir2.y;
					ecx = -(((dX * tMat.col1.x) + (dY * tMat.col1.y)));
					ecy = -(((dX * tMat.col2.x) + (dY * tMat.col2.y)));
				};
				if (((tVec2.x * ecx) + (tVec2.y * ecy)) >= 0){
					return;
				};
				manifold.pointCount = 1;
				manifold.normal.Set(((tMat.col1.x * tVec2.x) + (tMat.col2.x * tVec2.y)), ((tMat.col1.y * tVec2.x) + (tMat.col2.y * tVec2.y)));
				tPoint = manifold.points[0];
				tPoint.id.features.incidentEdge = separationIndex;
				tPoint.id.features.incidentVertex = b2Collision.b2_nullFeature;
				tPoint.id.features.referenceEdge = 0;
				tPoint.id.features.flip = 0;
				if (separationV1){
					tPoint.localPoint1.Set(v1x, v1y);
					tPoint.localPoint2.SetV(edge.m_v1);
				} else {
					tPoint.localPoint1.Set(v2x, v2y);
					tPoint.localPoint2.SetV(edge.m_v2);
				};
				tPoint.separation = separationMax;
			} else {
				manifold.normal.Set(-(edge.m_normal.x), -(edge.m_normal.y));
				tVec = vertices[enterEndIndex];
				if (enterEndIndex == exitStartIndex){
					manifold.pointCount = 1;
					tPoint = manifold.points[0];
					tPoint.id.features.incidentEdge = enterEndIndex;
					tPoint.id.features.incidentVertex = b2Collision.b2_nullFeature;
					tPoint.id.features.referenceEdge = 0;
					tPoint.id.features.flip = 0;
					tPoint.localPoint1.SetV(tVec);
					tPoint.localPoint2.Set((xf1.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y))), (xf1.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y))));
					tPoint.separation = enterEN;
					return;
				};
				manifold.pointCount = 2;
				dX = edge.m_direction.x;
				dY = edge.m_direction.y;
				edx = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
				edy = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
				ed1 = ((edx * (tVec.x - v1x)) + (edy * (tVec.y - v1y)));
				exitEndIndex = ((enterEndIndex)==(vertexCount - 1)) ? 0 : (enterEndIndex + 1);
				if (exitEndIndex != exitStartIndex){
					exitStartIndex = exitEndIndex;
					tVec2 = vertices[exitStartIndex];
					dX = (tVec2.x - v1x);
					dY = (tVec2.y - v1y);
					exitEN = ((enx * dX) + (eny * dY));
					ed2 = ((edx * dX) + (edy * dY));
				} else {
					tVec2 = vertices[exitStartIndex];
					ed2 = ((edx * (tVec2.x - v1x)) + (edy * (tVec2.y - v1y)));
				};
				tPoint = manifold.points[0];
				tPoint.id.features.incidentEdge = enterEndIndex;
				tPoint.id.features.incidentVertex = b2Collision.b2_nullFeature;
				tPoint.id.features.referenceEdge = 0;
				tPoint.id.features.flip = 0;
				if (ed1 > edge.m_length){
					tPoint.localPoint1.Set(v2x, v2y);
					tPoint.localPoint2.SetV(edge.m_v2);
					dX = ((edge.m_length - ed2) / (ed1 - ed2));
					if ((((dX > (100 * Number.MIN_VALUE))) && ((dX < 1)))){
						tPoint.separation = ((exitEN * (1 - dX)) + (enterEN * dX));
					} else {
						tPoint.separation = enterEN;
					};
				} else {
					tPoint.localPoint1.SetV(tVec);
					tPoint.localPoint2.Set((xf1.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y))), (xf1.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y))));
					tPoint.separation = enterEN;
				};
				tPoint = manifold.points[1];
				tPoint.id.features.incidentEdge = exitStartIndex;
				tPoint.id.features.incidentVertex = b2Collision.b2_nullFeature;
				tPoint.id.features.referenceEdge = 0;
				tPoint.id.features.flip = 0;
				if (ed2 < 0){
					tPoint.localPoint1.Set(v1x, v1y);
					tPoint.localPoint2.SetV(edge.m_v1);
					dX = (-(ed1) / (ed2 - ed1));
					if ((((dX > (100 * Number.MIN_VALUE))) && ((dX < 1)))){
						tPoint.separation = ((enterEN * (1 - dX)) + (exitEN * dX));
					} else {
						tPoint.separation = exitEN;
					};
				} else {
					tPoint.localPoint1.SetV(tVec2);
					tPoint.localPoint2.Set((xf1.position.x + ((tMat.col1.x * tVec2.x) + (tMat.col2.x * tVec2.y))), (xf1.position.y + ((tMat.col1.y * tVec2.x) + (tMat.col2.y * tVec2.y))));
					tPoint.separation = exitEN;
				};
				return;
			};
		}
		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2PolyAndStaticEdgeContact(shape1, shape2));
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 57
//b2PolygonContact (Box2D.Dynamics.Contacts.b2PolygonContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2PolygonContact extends b2Contact {

		public var m_manifolds:Array;
		public var m0:b2Manifold;
		public var m_manifold:b2Manifold;

		public static const s_evalCP:b2ContactPoint = new b2ContactPoint();

		public function b2PolygonContact(shape1:b2Shape, shape2:b2Shape):void{
			m0 = new b2Manifold();
			m_manifolds = [new b2Manifold()];
			super(shape1, shape2);
			m_manifold = m_manifolds[0];
			m_manifold.pointCount = 0;
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var v1:b2Vec2;
			var v2:b2Vec2;
			var mp0:b2ManifoldPoint;
			var cp:b2ContactPoint;
			var i:int;
			var mp:b2ManifoldPoint;
			var found:Boolean;
			var idKey:uint;
			var j:int;
			var b1:b2Body = m_shape1.m_body;
			var b2:b2Body = m_shape2.m_body;
			m0.Set(m_manifold);
			b2Collision.b2CollidePolygons(m_manifold, (m_shape1 as b2PolygonShape), b1.m_xf, (m_shape2 as b2PolygonShape), b2.m_xf);
			var persisted:Array = [false, false];
			cp = s_evalCP;
			cp.shape1 = m_shape1;
			cp.shape2 = m_shape2;
			cp.friction = m_friction;
			cp.restitution = m_restitution;
			if (m_manifold.pointCount > 0){
				i = 0;
				while (i < m_manifold.pointCount) {
					mp = m_manifold.points[i];
					mp.normalImpulse = 0;
					mp.tangentImpulse = 0;
					found = false;
					idKey = mp.id._key;
					j = 0;
					while (j < m0.pointCount) {
						if (persisted[j] == true){
						} else {
							mp0 = m0.points[j];
							if (mp0.id._key == idKey){
								persisted[j] = true;
								mp.normalImpulse = mp0.normalImpulse;
								mp.tangentImpulse = mp0.tangentImpulse;
								found = true;
								if (listener != null){
									cp.position = b1.GetWorldPoint(mp.localPoint1);
									v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
									v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
									cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
									cp.normal.SetV(m_manifold.normal);
									cp.separation = mp.separation;
									cp.id.key = idKey;
									listener.Persist(cp);
								};
								break;
							};
						};
						j++;
					};
					if ((((found == false)) && (!((listener == null))))){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = idKey;
						listener.Add(cp);
					};
					i++;
				};
				m_manifoldCount = 1;
			} else {
				m_manifoldCount = 0;
			};
			if (listener == null){
				return;
			};
			i = 0;
			while (i < m0.pointCount) {
				if (persisted[i]){
				} else {
					mp0 = m0.points[i];
					cp.position = b1.GetWorldPoint(mp0.localPoint1);
					v1 = b1.GetLinearVelocityFromLocalPoint(mp0.localPoint1);
					v2 = b2.GetLinearVelocityFromLocalPoint(mp0.localPoint2);
					cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
					cp.normal.SetV(m0.normal);
					cp.separation = mp0.separation;
					cp.id.key = mp0.id._key;
					listener.Remove(cp);
				};
				i++;
			};
		}
		override public function GetManifolds():Array{
			return (m_manifolds);
		}

		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2PolygonContact(shape1, shape2));
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 58
//b2StaticEdgeAndCircleContact (Box2D.Dynamics.Contacts.b2StaticEdgeAndCircleContact)
package Box2D.Dynamics.Contacts {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2StaticEdgeAndCircleContact extends b2Contact {

		private var m_manifolds:Array;
		public var m_manifold:b2Manifold;
		private var m0:b2Manifold;

		private static const s_evalCP:b2ContactPoint = new b2ContactPoint();

		public function b2StaticEdgeAndCircleContact(shape1:b2Shape, shape2:b2Shape){
			m_manifolds = [new b2Manifold()];
			m0 = new b2Manifold();
			super(shape1, shape2);
			m_manifold = m_manifolds[0];
			m_manifold.pointCount = 0;
			var point:b2ManifoldPoint = m_manifold.points[0];
			point.normalImpulse = 0;
			point.tangentImpulse = 0;
		}
		override public function Evaluate(listener:b2ContactListener):void{
			var v1:b2Vec2;
			var v2:b2Vec2;
			var mp0:b2ManifoldPoint;
			var mp:b2ManifoldPoint;
			var b1:b2Body = m_shape1.m_body;
			var b2:b2Body = m_shape2.m_body;
			m0.Set(m_manifold);
			b2CollideStaticEdgeAndCircle(m_manifold, (m_shape1 as b2StaticEdgeShape), b1.m_xf, (m_shape2 as b2CircleShape), b2.m_xf);
			var cp:b2ContactPoint = s_evalCP;
			cp.shape1 = m_shape1;
			cp.shape2 = m_shape2;
			cp.friction = m_friction;
			cp.restitution = m_restitution;
			if (m_manifold.pointCount > 0){
				m_manifoldCount = 1;
				mp = m_manifold.points[0];
				if (m0.pointCount == 0){
					mp.normalImpulse = 0;
					mp.tangentImpulse = 0;
					if (listener){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = mp.id._key;
						listener.Add(cp);
					};
				} else {
					mp0 = m0.points[0];
					mp.normalImpulse = mp0.normalImpulse;
					mp.tangentImpulse = mp0.tangentImpulse;
					if (listener){
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.normal.SetV(m_manifold.normal);
						cp.separation = mp.separation;
						cp.id.key = mp.id._key;
						listener.Persist(cp);
					};
				};
			} else {
				m_manifoldCount = 0;
				if ((((m0.pointCount > 0)) && (listener))){
					mp0 = m0.points[0];
					cp.position = b1.GetWorldPoint(mp0.localPoint1);
					v1 = b1.GetLinearVelocityFromLocalPoint(mp0.localPoint1);
					v2 = b2.GetLinearVelocityFromLocalPoint(mp0.localPoint2);
					cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
					cp.normal.SetV(m0.normal);
					cp.separation = mp0.separation;
					cp.id.key = mp0.id._key;
					listener.Remove(cp);
				};
			};
		}
		override public function GetManifolds():Array{
			return (m_manifolds);
		}

		public static function Destroy(contact:b2Contact, allocator):void{
		}
		public static function Create(shape1:b2Shape, shape2:b2Shape, allocator):b2Contact{
			return (new b2StaticEdgeAndCircleContact(shape1, shape2));
		}
		public static function b2CollideStaticEdgeAndCircle(manifold:b2Manifold, edge:b2StaticEdgeShape, xf1:b2XForm, circle:b2CircleShape, xf2:b2XForm):void{
			var dX:Number;
			var dY:Number;
			var separation:Number;
			var tPoint:b2ManifoldPoint;
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var circleX:Number;
			var circleY:Number;
			var dist:Number;
			var a:Number;
			manifold.pointCount = 0;
			tMat = xf2.R;
			tVec = circle.m_localPosition;
			circleX = (xf2.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			circleY = (xf2.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			var dirDist:Number = (((circleX - edge.m_v1.x) * edge.m_direction.x) + ((circleY - edge.m_v1.y) * edge.m_direction.y));
			if (dirDist <= 0){
				dX = (circleX - edge.m_v1.x);
				dY = (circleY - edge.m_v1.y);
				if (((dX * edge.m_cornerDir1.x) + (dY * edge.m_cornerDir1.y)) < 0){
					return;
				};
			} else {
				if (dirDist >= edge.m_length){
					dX = (circleX - edge.m_v2.x);
					dY = (circleY - edge.m_v2.y);
					if (((dX * edge.m_cornerDir2.x) + (dY * edge.m_cornerDir2.y)) > 0){
						return;
					};
				} else {
					tVec = edge.m_normal;
					separation = (((circleX - edge.m_v1.x) * tVec.x) + ((circleY - edge.m_v1.y) * tVec.y));
					if ((((separation > circle.m_radius)) || ((separation < -(circle.m_radius))))){
						return;
					};
					separation = (separation - circle.m_radius);
					manifold.normal.x = tVec.x;
					manifold.normal.y = tVec.y;
					manifold.pointCount = 1;
					tPoint = manifold.points[0];
					tPoint.id.key = 0;
					tPoint.separation = separation;
					circleX = (circleX - (circle.m_radius * tVec.x));
					circleY = (circleY - (circle.m_radius * tVec.y));
					tPoint.localPoint1.x = circleX;
					tPoint.localPoint1.y = circleY;
					dX = (circleX - xf2.position.x);
					dY = (circleY - xf2.position.y);
					tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
					tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
					return;
				};
			};
			var distSqr:Number = ((dX * dX) + (dY * dY));
			if (distSqr > (circle.m_radius * circle.m_radius)){
				return;
			};
			if (distSqr < Number.MIN_VALUE){
				separation = -(circle.m_radius);
				manifold.normal.SetV(edge.m_normal);
			} else {
				dist = Math.sqrt(distSqr);
				separation = (dist - circle.m_radius);
				a = (1 / dist);
				manifold.normal.x = (a * dX);
				manifold.normal.y = (a * dY);
			};
			manifold.pointCount = 1;
			tPoint = manifold.points[0];
			tPoint.id.key = 0;
			tPoint.separation = separation;
			circleX = (circleX - (circle.m_radius * manifold.normal.x));
			circleY = (circleY - (circle.m_radius * manifold.normal.y));
			tPoint.localPoint1.x = circleX;
			tPoint.localPoint1.y = circleY;
			dX = (circleX - xf2.position.x);
			dY = (circleY - xf2.position.y);
			tPoint.localPoint2.x = ((dX * tMat.col1.x) + (dY * tMat.col1.y));
			tPoint.localPoint2.y = ((dX * tMat.col2.x) + (dY * tMat.col2.y));
		}

	}
}//package Box2D.Dynamics.Contacts 
Section 59
//b2DistanceJoint (Box2D.Dynamics.Joints.b2DistanceJoint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2DistanceJoint extends b2Joint {

		public var m_localAnchor1:b2Vec2;
		public var m_localAnchor2:b2Vec2;
		public var m_bias:Number;
		public var m_gamma:Number;
		public var m_u:b2Vec2;
		public var m_mass:Number;
		public var m_impulse:Number;
		public var m_dampingRatio:Number;
		public var m_frequencyHz:Number;
		public var m_length:Number;

		public function b2DistanceJoint(def:b2DistanceJointDef){
			var tMat:b2Mat22;
			var tX:Number;
			var tY:Number;
			m_localAnchor1 = new b2Vec2();
			m_localAnchor2 = new b2Vec2();
			m_u = new b2Vec2();
			super(def);
			m_localAnchor1.SetV(def.localAnchor1);
			m_localAnchor2.SetV(def.localAnchor2);
			m_length = def.length;
			m_frequencyHz = def.frequencyHz;
			m_dampingRatio = def.dampingRatio;
			m_impulse = 0;
			m_gamma = 0;
			m_bias = 0;
			m_inv_dt = 0;
		}
		override public function GetAnchor1():b2Vec2{
			return (m_body1.GetWorldPoint(m_localAnchor1));
		}
		override public function GetAnchor2():b2Vec2{
			return (m_body2.GetWorldPoint(m_localAnchor2));
		}
		override public function InitVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var tX:Number;
			var b1:b2Body;
			var b2:b2Body;
			var r1X:Number;
			var r2X:Number;
			var C:Number;
			var omega:Number;
			var d:Number;
			var k:Number;
			var PX:Number;
			var PY:Number;
			m_inv_dt = step.inv_dt;
			b1 = m_body1;
			b2 = m_body2;
			tMat = b1.m_xf.R;
			r1X = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			r2X = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			m_u.x = (((b2.m_sweep.c.x + r2X) - b1.m_sweep.c.x) - r1X);
			m_u.y = (((b2.m_sweep.c.y + r2Y) - b1.m_sweep.c.y) - r1Y);
			var length:Number = Math.sqrt(((m_u.x * m_u.x) + (m_u.y * m_u.y)));
			if (length > b2Settings.b2_linearSlop){
				m_u.Multiply((1 / length));
			} else {
				m_u.SetZero();
			};
			var cr1u:Number = ((r1X * m_u.y) - (r1Y * m_u.x));
			var cr2u:Number = ((r2X * m_u.y) - (r2Y * m_u.x));
			var invMass:Number = (((b1.m_invMass + ((b1.m_invI * cr1u) * cr1u)) + b2.m_invMass) + ((b2.m_invI * cr2u) * cr2u));
			m_mass = (1 / invMass);
			if (m_frequencyHz > 0){
				C = (length - m_length);
				omega = ((2 * Math.PI) * m_frequencyHz);
				d = (((2 * m_mass) * m_dampingRatio) * omega);
				k = ((m_mass * omega) * omega);
				m_gamma = (1 / (step.dt * (d + (step.dt * k))));
				m_bias = (((C * step.dt) * k) * m_gamma);
				m_mass = (1 / (invMass + m_gamma));
			};
			if (step.warmStarting){
				m_impulse = (m_impulse * step.dtRatio);
				PX = (m_impulse * m_u.x);
				PY = (m_impulse * m_u.y);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x - (b1.m_invMass * PX));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y - (b1.m_invMass * PY));
				b1.m_angularVelocity = (b1.m_angularVelocity - (b1.m_invI * ((r1X * PY) - (r1Y * PX))));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (b2.m_invMass * PX));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (b2.m_invMass * PY));
				b2.m_angularVelocity = (b2.m_angularVelocity + (b2.m_invI * ((r2X * PY) - (r2Y * PX))));
			} else {
				m_impulse = 0;
			};
		}
		override public function GetReactionTorque():Number{
			return (0);
		}
		override public function GetReactionForce():b2Vec2{
			var F:b2Vec2 = new b2Vec2();
			F.SetV(m_u);
			F.Multiply((m_inv_dt * m_impulse));
			return (F);
		}
		override public function SolvePositionConstraints():Boolean{
			var tMat:b2Mat22;
			if (m_frequencyHz > 0){
				return (true);
			};
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var dX:Number = (((b2.m_sweep.c.x + r2X) - b1.m_sweep.c.x) - r1X);
			var dY:Number = (((b2.m_sweep.c.y + r2Y) - b1.m_sweep.c.y) - r1Y);
			var length:Number = Math.sqrt(((dX * dX) + (dY * dY)));
			dX = (dX / length);
			dY = (dY / length);
			var C:Number = (length - m_length);
			C = b2Math.b2Clamp(C, -(b2Settings.b2_maxLinearCorrection), b2Settings.b2_maxLinearCorrection);
			var impulse:Number = (-(m_mass) * C);
			m_u.Set(dX, dY);
			var PX:Number = (impulse * m_u.x);
			var PY:Number = (impulse * m_u.y);
			b1.m_sweep.c.x = (b1.m_sweep.c.x - (b1.m_invMass * PX));
			b1.m_sweep.c.y = (b1.m_sweep.c.y - (b1.m_invMass * PY));
			b1.m_sweep.a = (b1.m_sweep.a - (b1.m_invI * ((r1X * PY) - (r1Y * PX))));
			b2.m_sweep.c.x = (b2.m_sweep.c.x + (b2.m_invMass * PX));
			b2.m_sweep.c.y = (b2.m_sweep.c.y + (b2.m_invMass * PY));
			b2.m_sweep.a = (b2.m_sweep.a + (b2.m_invI * ((r2X * PY) - (r2Y * PX))));
			b1.SynchronizeTransform();
			b2.SynchronizeTransform();
			return ((b2Math.b2Abs(C) < b2Settings.b2_linearSlop));
		}
		override public function SolveVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var v1X:Number = (b1.m_linearVelocity.x + (-(b1.m_angularVelocity) * r1Y));
			var v1Y:Number = (b1.m_linearVelocity.y + (b1.m_angularVelocity * r1X));
			var v2X:Number = (b2.m_linearVelocity.x + (-(b2.m_angularVelocity) * r2Y));
			var v2Y:Number = (b2.m_linearVelocity.y + (b2.m_angularVelocity * r2X));
			var Cdot:Number = ((m_u.x * (v2X - v1X)) + (m_u.y * (v2Y - v1Y)));
			var impulse:Number = (-(m_mass) * ((Cdot + m_bias) + (m_gamma * m_impulse)));
			m_impulse = (m_impulse + impulse);
			var PX:Number = (impulse * m_u.x);
			var PY:Number = (impulse * m_u.y);
			b1.m_linearVelocity.x = (b1.m_linearVelocity.x - (b1.m_invMass * PX));
			b1.m_linearVelocity.y = (b1.m_linearVelocity.y - (b1.m_invMass * PY));
			b1.m_angularVelocity = (b1.m_angularVelocity - (b1.m_invI * ((r1X * PY) - (r1Y * PX))));
			b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (b2.m_invMass * PX));
			b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (b2.m_invMass * PY));
			b2.m_angularVelocity = (b2.m_angularVelocity + (b2.m_invI * ((r2X * PY) - (r2Y * PX))));
		}

	}
}//package Box2D.Dynamics.Joints 
Section 60
//b2DistanceJointDef (Box2D.Dynamics.Joints.b2DistanceJointDef)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;

	public class b2DistanceJointDef extends b2JointDef {

		public var localAnchor1:b2Vec2;
		public var length:Number;
		public var dampingRatio:Number;
		public var localAnchor2:b2Vec2;
		public var frequencyHz:Number;

		public function b2DistanceJointDef(){
			localAnchor1 = new b2Vec2();
			localAnchor2 = new b2Vec2();
			super();
			type = b2Joint.e_distanceJoint;
			length = 1;
			frequencyHz = 0;
			dampingRatio = 0;
		}
		public function Initialize(b1:b2Body, b2:b2Body, anchor1:b2Vec2, anchor2:b2Vec2):void{
			body1 = b1;
			body2 = b2;
			localAnchor1.SetV(body1.GetLocalPoint(anchor1));
			localAnchor2.SetV(body2.GetLocalPoint(anchor2));
			var dX:Number = (anchor2.x - anchor1.x);
			var dY:Number = (anchor2.y - anchor1.y);
			length = Math.sqrt(((dX * dX) + (dY * dY)));
			frequencyHz = 0;
			dampingRatio = 0;
		}

	}
}//package Box2D.Dynamics.Joints 
Section 61
//b2GearJoint (Box2D.Dynamics.Joints.b2GearJoint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2GearJoint extends b2Joint {

		public var m_ground2:b2Body;
		public var m_groundAnchor1:b2Vec2;
		public var m_groundAnchor2:b2Vec2;
		public var m_localAnchor1:b2Vec2;
		public var m_localAnchor2:b2Vec2;
		public var m_ratio:Number;
		public var m_revolute2:b2RevoluteJoint;
		public var m_force:Number;
		public var m_mass:Number;
		public var m_prismatic2:b2PrismaticJoint;
		public var m_ground1:b2Body;
		public var m_revolute1:b2RevoluteJoint;
		public var m_prismatic1:b2PrismaticJoint;
		public var m_constant:Number;
		public var m_J:b2Jacobian;

		public function b2GearJoint(def:b2GearJointDef){
			var coordinate1:Number;
			var coordinate2:Number;
			m_groundAnchor1 = new b2Vec2();
			m_groundAnchor2 = new b2Vec2();
			m_localAnchor1 = new b2Vec2();
			m_localAnchor2 = new b2Vec2();
			m_J = new b2Jacobian();
			super(def);
			var type1:int = def.joint1.m_type;
			var type2:int = def.joint2.m_type;
			m_revolute1 = null;
			m_prismatic1 = null;
			m_revolute2 = null;
			m_prismatic2 = null;
			m_ground1 = def.joint1.m_body1;
			m_body1 = def.joint1.m_body2;
			if (type1 == b2Joint.e_revoluteJoint){
				m_revolute1 = (def.joint1 as b2RevoluteJoint);
				m_groundAnchor1.SetV(m_revolute1.m_localAnchor1);
				m_localAnchor1.SetV(m_revolute1.m_localAnchor2);
				coordinate1 = m_revolute1.GetJointAngle();
			} else {
				m_prismatic1 = (def.joint1 as b2PrismaticJoint);
				m_groundAnchor1.SetV(m_prismatic1.m_localAnchor1);
				m_localAnchor1.SetV(m_prismatic1.m_localAnchor2);
				coordinate1 = m_prismatic1.GetJointTranslation();
			};
			m_ground2 = def.joint2.m_body1;
			m_body2 = def.joint2.m_body2;
			if (type2 == b2Joint.e_revoluteJoint){
				m_revolute2 = (def.joint2 as b2RevoluteJoint);
				m_groundAnchor2.SetV(m_revolute2.m_localAnchor1);
				m_localAnchor2.SetV(m_revolute2.m_localAnchor2);
				coordinate2 = m_revolute2.GetJointAngle();
			} else {
				m_prismatic2 = (def.joint2 as b2PrismaticJoint);
				m_groundAnchor2.SetV(m_prismatic2.m_localAnchor1);
				m_localAnchor2.SetV(m_prismatic2.m_localAnchor2);
				coordinate2 = m_prismatic2.GetJointTranslation();
			};
			m_ratio = def.ratio;
			m_constant = (coordinate1 + (m_ratio * coordinate2));
			m_force = 0;
		}
		override public function GetAnchor1():b2Vec2{
			return (m_body1.GetWorldPoint(m_localAnchor1));
		}
		override public function GetAnchor2():b2Vec2{
			return (m_body2.GetWorldPoint(m_localAnchor2));
		}
		override public function InitVelocityConstraints(step:b2TimeStep):void{
			var ugX:Number;
			var ugY:Number;
			var rX:Number;
			var rY:Number;
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var crug:Number;
			var tX:Number;
			var P:Number;
			var g1:b2Body = m_ground1;
			var g2:b2Body = m_ground2;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var K:Number = 0;
			m_J.SetZero();
			if (m_revolute1){
				m_J.angular1 = -1;
				K = (K + b1.m_invI);
			} else {
				tMat = g1.m_xf.R;
				tVec = m_prismatic1.m_localXAxis1;
				ugX = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
				ugY = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
				tMat = b1.m_xf.R;
				rX = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
				rY = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * rX) + (tMat.col2.x * rY));
				rY = ((tMat.col1.y * rX) + (tMat.col2.y * rY));
				rX = tX;
				crug = ((rX * ugY) - (rY * ugX));
				m_J.linear1.Set(-(ugX), -(ugY));
				m_J.angular1 = -(crug);
				K = (K + (b1.m_invMass + ((b1.m_invI * crug) * crug)));
			};
			if (m_revolute2){
				m_J.angular2 = -(m_ratio);
				K = (K + ((m_ratio * m_ratio) * b2.m_invI));
			} else {
				tMat = g2.m_xf.R;
				tVec = m_prismatic2.m_localXAxis1;
				ugX = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
				ugY = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
				tMat = b2.m_xf.R;
				rX = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
				rY = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * rX) + (tMat.col2.x * rY));
				rY = ((tMat.col1.y * rX) + (tMat.col2.y * rY));
				rX = tX;
				crug = ((rX * ugY) - (rY * ugX));
				m_J.linear2.Set((-(m_ratio) * ugX), (-(m_ratio) * ugY));
				m_J.angular2 = (-(m_ratio) * crug);
				K = (K + ((m_ratio * m_ratio) * (b2.m_invMass + ((b2.m_invI * crug) * crug))));
			};
			m_mass = (1 / K);
			if (step.warmStarting){
				P = (step.dt * m_force);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + ((b1.m_invMass * P) * m_J.linear1.x));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + ((b1.m_invMass * P) * m_J.linear1.y));
				b1.m_angularVelocity = (b1.m_angularVelocity + ((b1.m_invI * P) * m_J.angular1));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + ((b2.m_invMass * P) * m_J.linear2.x));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + ((b2.m_invMass * P) * m_J.linear2.y));
				b2.m_angularVelocity = (b2.m_angularVelocity + ((b2.m_invI * P) * m_J.angular2));
			} else {
				m_force = 0;
			};
		}
		override public function GetReactionTorque():Number{
			var tMat:b2Mat22 = m_body2.m_xf.R;
			var rX:Number = (m_localAnchor1.x - m_body2.m_sweep.localCenter.x);
			var rY:Number = (m_localAnchor1.y - m_body2.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * rX) + (tMat.col2.x * rY));
			rY = ((tMat.col1.y * rX) + (tMat.col2.y * rY));
			rX = tX;
			tX = ((m_force * m_J.angular2) - ((rX * (m_force * m_J.linear2.y)) - (rY * (m_force * m_J.linear2.x))));
			return (tX);
		}
		override public function GetReactionForce():b2Vec2{
			var F:b2Vec2 = new b2Vec2((m_force * m_J.linear2.x), (m_force * m_J.linear2.y));
			return (F);
		}
		override public function SolvePositionConstraints():Boolean{
			var coordinate1:Number;
			var coordinate2:Number;
			var linearError:Number = 0;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			if (m_revolute1){
				coordinate1 = m_revolute1.GetJointAngle();
			} else {
				coordinate1 = m_prismatic1.GetJointTranslation();
			};
			if (m_revolute2){
				coordinate2 = m_revolute2.GetJointAngle();
			} else {
				coordinate2 = m_prismatic2.GetJointTranslation();
			};
			var C:Number = (m_constant - (coordinate1 + (m_ratio * coordinate2)));
			var impulse:Number = (-(m_mass) * C);
			b1.m_sweep.c.x = (b1.m_sweep.c.x + ((b1.m_invMass * impulse) * m_J.linear1.x));
			b1.m_sweep.c.y = (b1.m_sweep.c.y + ((b1.m_invMass * impulse) * m_J.linear1.y));
			b1.m_sweep.a = (b1.m_sweep.a + ((b1.m_invI * impulse) * m_J.angular1));
			b2.m_sweep.c.x = (b2.m_sweep.c.x + ((b2.m_invMass * impulse) * m_J.linear2.x));
			b2.m_sweep.c.y = (b2.m_sweep.c.y + ((b2.m_invMass * impulse) * m_J.linear2.y));
			b2.m_sweep.a = (b2.m_sweep.a + ((b2.m_invI * impulse) * m_J.angular2));
			b1.SynchronizeTransform();
			b2.SynchronizeTransform();
			return ((linearError < b2Settings.b2_linearSlop));
		}
		public function GetRatio():Number{
			return (m_ratio);
		}
		override public function SolveVelocityConstraints(step:b2TimeStep):void{
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var Cdot:Number = m_J.Compute(b1.m_linearVelocity, b1.m_angularVelocity, b2.m_linearVelocity, b2.m_angularVelocity);
			var force:Number = ((-(step.inv_dt) * m_mass) * Cdot);
			m_force = (m_force + force);
			var P:Number = (step.dt * force);
			b1.m_linearVelocity.x = (b1.m_linearVelocity.x + ((b1.m_invMass * P) * m_J.linear1.x));
			b1.m_linearVelocity.y = (b1.m_linearVelocity.y + ((b1.m_invMass * P) * m_J.linear1.y));
			b1.m_angularVelocity = (b1.m_angularVelocity + ((b1.m_invI * P) * m_J.angular1));
			b2.m_linearVelocity.x = (b2.m_linearVelocity.x + ((b2.m_invMass * P) * m_J.linear2.x));
			b2.m_linearVelocity.y = (b2.m_linearVelocity.y + ((b2.m_invMass * P) * m_J.linear2.y));
			b2.m_angularVelocity = (b2.m_angularVelocity + ((b2.m_invI * P) * m_J.angular2));
		}

	}
}//package Box2D.Dynamics.Joints 
Section 62
//b2GearJointDef (Box2D.Dynamics.Joints.b2GearJointDef)
package Box2D.Dynamics.Joints {

	public class b2GearJointDef extends b2JointDef {

		public var joint1:b2Joint;
		public var joint2:b2Joint;
		public var ratio:Number;

		public function b2GearJointDef(){
			super();
			type = b2Joint.e_gearJoint;
			joint1 = null;
			joint2 = null;
			ratio = 1;
		}
	}
}//package Box2D.Dynamics.Joints 
Section 63
//b2Jacobian (Box2D.Dynamics.Joints.b2Jacobian)
package Box2D.Dynamics.Joints {
	import Box2D.Common.Math.*;

	public class b2Jacobian {

		public var linear1:b2Vec2;
		public var linear2:b2Vec2;
		public var angular1:Number;
		public var angular2:Number;

		public function b2Jacobian(){
			linear1 = new b2Vec2();
			linear2 = new b2Vec2();
			super();
		}
		public function Set(x1:b2Vec2, a1:Number, x2:b2Vec2, a2:Number):void{
			linear1.SetV(x1);
			angular1 = a1;
			linear2.SetV(x2);
			angular2 = a2;
		}
		public function SetZero():void{
			linear1.SetZero();
			angular1 = 0;
			linear2.SetZero();
			angular2 = 0;
		}
		public function Compute(x1:b2Vec2, a1:Number, x2:b2Vec2, a2:Number):Number{
			return ((((((linear1.x * x1.x) + (linear1.y * x1.y)) + (angular1 * a1)) + ((linear2.x * x2.x) + (linear2.y * x2.y))) + (angular2 * a2)));
		}

	}
}//package Box2D.Dynamics.Joints 
Section 64
//b2Joint (Box2D.Dynamics.Joints.b2Joint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;

	public class b2Joint {

		public var m_islandFlag:Boolean;
		public var m_body1:b2Body;
		public var m_prev:b2Joint;
		public var m_next:b2Joint;
		public var m_type:int;
		public var m_collideConnected:Boolean;
		public var m_node1:b2JointEdge;
		public var m_node2:b2JointEdge;
		public var m_inv_dt:Number;
		public var m_userData;
		public var m_body2:b2Body;

		public static const e_unknownJoint:int = 0;
		public static const e_inactiveLimit:int = 0;
		public static const e_atUpperLimit:int = 2;
		public static const e_atLowerLimit:int = 1;
		public static const e_gearJoint:int = 6;
		public static const e_revoluteJoint:int = 1;
		public static const e_equalLimits:int = 3;
		public static const e_distanceJoint:int = 3;
		public static const e_pulleyJoint:int = 4;
		public static const e_prismaticJoint:int = 2;
		public static const e_mouseJoint:int = 5;

		public function b2Joint(def:b2JointDef){
			m_node1 = new b2JointEdge();
			m_node2 = new b2JointEdge();
			super();
			m_type = def.type;
			m_prev = null;
			m_next = null;
			m_body1 = def.body1;
			m_body2 = def.body2;
			m_collideConnected = def.collideConnected;
			m_islandFlag = false;
			m_userData = def.userData;
		}
		public function GetBody2():b2Body{
			return (m_body2);
		}
		public function GetAnchor1():b2Vec2{
			return (null);
		}
		public function GetAnchor2():b2Vec2{
			return (null);
		}
		public function GetNext():b2Joint{
			return (m_next);
		}
		public function GetType():int{
			return (m_type);
		}
		public function InitVelocityConstraints(step:b2TimeStep):void{
		}
		public function GetReactionTorque():Number{
			return (0);
		}
		public function GetUserData(){
			return (m_userData);
		}
		public function GetReactionForce():b2Vec2{
			return (null);
		}
		public function SolvePositionConstraints():Boolean{
			return (false);
		}
		public function SetUserData(data):void{
			m_userData = data;
		}
		public function GetBody1():b2Body{
			return (m_body1);
		}
		public function SolveVelocityConstraints(step:b2TimeStep):void{
		}
		public function InitPositionConstraints():void{
		}

		public static function Destroy(joint:b2Joint, allocator):void{
		}
		public static function Create(def:b2JointDef, allocator):b2Joint{
			var joint:b2Joint;
			switch (def.type){
				case e_distanceJoint:
					joint = new b2DistanceJoint((def as b2DistanceJointDef));
					break;
				case e_mouseJoint:
					joint = new b2MouseJoint((def as b2MouseJointDef));
					break;
				case e_prismaticJoint:
					joint = new b2PrismaticJoint((def as b2PrismaticJointDef));
					break;
				case e_revoluteJoint:
					joint = new b2RevoluteJoint((def as b2RevoluteJointDef));
					break;
				case e_pulleyJoint:
					joint = new b2PulleyJoint((def as b2PulleyJointDef));
					break;
				case e_gearJoint:
					joint = new b2GearJoint((def as b2GearJointDef));
					break;
				default:
					break;
			};
			return (joint);
		}

	}
}//package Box2D.Dynamics.Joints 
Section 65
//b2JointDef (Box2D.Dynamics.Joints.b2JointDef)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;

	public class b2JointDef {

		public var body2:b2Body;
		public var type:int;
		public var userData;
		public var collideConnected:Boolean;
		public var body1:b2Body;

		public function b2JointDef(){
			super();
			type = b2Joint.e_unknownJoint;
			userData = null;
			body1 = null;
			body2 = null;
			collideConnected = false;
		}
	}
}//package Box2D.Dynamics.Joints 
Section 66
//b2JointEdge (Box2D.Dynamics.Joints.b2JointEdge)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;

	public class b2JointEdge {

		public var other:b2Body;
		public var next:b2JointEdge;
		public var prev:b2JointEdge;
		public var joint:b2Joint;

		public function b2JointEdge(){
			super();
		}
	}
}//package Box2D.Dynamics.Joints 
Section 67
//b2MouseJoint (Box2D.Dynamics.Joints.b2MouseJoint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2MouseJoint extends b2Joint {

		private var K1:b2Mat22;
		private var K:b2Mat22;
		public var m_beta:Number;
		public var m_mass:b2Mat22;
		private var K2:b2Mat22;
		public var m_target:b2Vec2;
		public var m_gamma:Number;
		public var m_impulse:b2Vec2;
		public var m_C:b2Vec2;
		public var m_localAnchor:b2Vec2;
		public var m_maxForce:Number;

		public function b2MouseJoint(def:b2MouseJointDef){
			var tY:Number;
			K = new b2Mat22();
			K1 = new b2Mat22();
			K2 = new b2Mat22();
			m_localAnchor = new b2Vec2();
			m_target = new b2Vec2();
			m_impulse = new b2Vec2();
			m_mass = new b2Mat22();
			m_C = new b2Vec2();
			super(def);
			m_target.SetV(def.target);
			var tX:Number = (m_target.x - m_body2.m_xf.position.x);
			tY = (m_target.y - m_body2.m_xf.position.y);
			var tMat:b2Mat22 = m_body2.m_xf.R;
			m_localAnchor.x = ((tX * tMat.col1.x) + (tY * tMat.col1.y));
			m_localAnchor.y = ((tX * tMat.col2.x) + (tY * tMat.col2.y));
			m_maxForce = def.maxForce;
			m_impulse.SetZero();
			var mass:Number = m_body2.m_mass;
			var omega:Number = ((2 * b2Settings.b2_pi) * def.frequencyHz);
			var d:Number = (((2 * mass) * def.dampingRatio) * omega);
			var k:Number = ((def.timeStep * mass) * (omega * omega));
			m_gamma = (1 / (d + k));
			m_beta = (k / (d + k));
		}
		public function SetTarget(target:b2Vec2):void{
			if (m_body2.IsSleeping()){
				m_body2.WakeUp();
			};
			m_target = target;
		}
		override public function GetAnchor2():b2Vec2{
			return (m_body2.GetWorldPoint(m_localAnchor));
		}
		override public function InitVelocityConstraints(step:b2TimeStep):void{
			var b:b2Body;
			var tMat:b2Mat22;
			var rX:Number;
			var rY:Number;
			var invMass:Number;
			var invI:Number;
			b = m_body2;
			tMat = b.m_xf.R;
			rX = (m_localAnchor.x - b.m_sweep.localCenter.x);
			rY = (m_localAnchor.y - b.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * rX) + (tMat.col2.x * rY));
			rY = ((tMat.col1.y * rX) + (tMat.col2.y * rY));
			rX = tX;
			invMass = b.m_invMass;
			invI = b.m_invI;
			K1.col1.x = invMass;
			K1.col2.x = 0;
			K1.col1.y = 0;
			K1.col2.y = invMass;
			K2.col1.x = ((invI * rY) * rY);
			K2.col2.x = ((-(invI) * rX) * rY);
			K2.col1.y = ((-(invI) * rX) * rY);
			K2.col2.y = ((invI * rX) * rX);
			K.SetM(K1);
			K.AddM(K2);
			K.col1.x = (K.col1.x + m_gamma);
			K.col2.y = (K.col2.y + m_gamma);
			K.Invert(m_mass);
			m_C.x = ((b.m_sweep.c.x + rX) - m_target.x);
			m_C.y = ((b.m_sweep.c.y + rY) - m_target.y);
			b.m_angularVelocity = (b.m_angularVelocity * 0.98);
			var PX:Number = (step.dt * m_impulse.x);
			var PY:Number = (step.dt * m_impulse.y);
			b.m_linearVelocity.x = (b.m_linearVelocity.x + (invMass * PX));
			b.m_linearVelocity.y = (b.m_linearVelocity.y + (invMass * PY));
			b.m_angularVelocity = (b.m_angularVelocity + (invI * ((rX * PY) - (rY * PX))));
		}
		override public function GetAnchor1():b2Vec2{
			return (m_target);
		}
		override public function GetReactionTorque():Number{
			return (0);
		}
		override public function GetReactionForce():b2Vec2{
			return (m_impulse);
		}
		override public function SolvePositionConstraints():Boolean{
			return (true);
		}
		override public function SolveVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var tX:Number;
			var tY:Number;
			var b:b2Body = m_body2;
			tMat = b.m_xf.R;
			var rX:Number = (m_localAnchor.x - b.m_sweep.localCenter.x);
			var rY:Number = (m_localAnchor.y - b.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * rX) + (tMat.col2.x * rY));
			rY = ((tMat.col1.y * rX) + (tMat.col2.y * rY));
			rX = tX;
			var CdotX:Number = (b.m_linearVelocity.x + (-(b.m_angularVelocity) * rY));
			var CdotY:Number = (b.m_linearVelocity.y + (b.m_angularVelocity * rX));
			tMat = m_mass;
			tX = ((CdotX + ((m_beta * step.inv_dt) * m_C.x)) + ((m_gamma * step.dt) * m_impulse.x));
			tY = ((CdotY + ((m_beta * step.inv_dt) * m_C.y)) + ((m_gamma * step.dt) * m_impulse.y));
			var forceX:Number = (-(step.inv_dt) * ((tMat.col1.x * tX) + (tMat.col2.x * tY)));
			var forceY:Number = (-(step.inv_dt) * ((tMat.col1.y * tX) + (tMat.col2.y * tY)));
			var oldForceX:Number = m_impulse.x;
			var oldForceY:Number = m_impulse.y;
			m_impulse.x = (m_impulse.x + forceX);
			m_impulse.y = (m_impulse.y + forceY);
			var forceMagnitude:Number = m_impulse.Length();
			if (forceMagnitude > m_maxForce){
				m_impulse.Multiply((m_maxForce / forceMagnitude));
			};
			forceX = (m_impulse.x - oldForceX);
			forceY = (m_impulse.y - oldForceY);
			var PX:Number = (step.dt * forceX);
			var PY:Number = (step.dt * forceY);
			b.m_linearVelocity.x = (b.m_linearVelocity.x + (b.m_invMass * PX));
			b.m_linearVelocity.y = (b.m_linearVelocity.y + (b.m_invMass * PY));
			b.m_angularVelocity = (b.m_angularVelocity + (b.m_invI * ((rX * PY) - (rY * PX))));
		}

	}
}//package Box2D.Dynamics.Joints 
Section 68
//b2MouseJointDef (Box2D.Dynamics.Joints.b2MouseJointDef)
package Box2D.Dynamics.Joints {
	import Box2D.Common.Math.*;

	public class b2MouseJointDef extends b2JointDef {

		public var timeStep:Number;
		public var target:b2Vec2;
		public var maxForce:Number;
		public var dampingRatio:Number;
		public var frequencyHz:Number;

		public function b2MouseJointDef(){
			target = new b2Vec2();
			super();
			type = b2Joint.e_mouseJoint;
			maxForce = 0;
			frequencyHz = 5;
			dampingRatio = 0.7;
			timeStep = (1 / 60);
		}
	}
}//package Box2D.Dynamics.Joints 
Section 69
//b2PrismaticJoint (Box2D.Dynamics.Joints.b2PrismaticJoint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2PrismaticJoint extends b2Joint {

		public var m_limitForce:Number;
		public var m_lowerTranslation:Number;
		public var m_localXAxis1:b2Vec2;
		public var m_refAngle:Number;
		public var m_torque:Number;
		public var m_motorForce:Number;
		public var m_enableLimit:Boolean;
		public var m_angularMass:Number;
		public var m_maxMotorForce:Number;
		public var m_localYAxis1:b2Vec2;
		public var m_force:Number;
		public var m_motorMass:Number;
		public var m_upperTranslation:Number;
		public var m_localAnchor1:b2Vec2;
		public var m_localAnchor2:b2Vec2;
		public var m_limitState:int;
		public var m_linearMass:Number;
		public var m_motorJacobian:b2Jacobian;
		public var m_limitPositionImpulse:Number;
		public var m_motorSpeed:Number;
		public var m_enableMotor:Boolean;
		public var m_linearJacobian:b2Jacobian;

		public function b2PrismaticJoint(def:b2PrismaticJointDef){
			var tMat:b2Mat22;
			var tX:Number;
			var tY:Number;
			m_localAnchor1 = new b2Vec2();
			m_localAnchor2 = new b2Vec2();
			m_localXAxis1 = new b2Vec2();
			m_localYAxis1 = new b2Vec2();
			m_linearJacobian = new b2Jacobian();
			m_motorJacobian = new b2Jacobian();
			super(def);
			m_localAnchor1.SetV(def.localAnchor1);
			m_localAnchor2.SetV(def.localAnchor2);
			m_localXAxis1.SetV(def.localAxis1);
			m_localYAxis1.x = -(m_localXAxis1.y);
			m_localYAxis1.y = m_localXAxis1.x;
			m_refAngle = def.referenceAngle;
			m_linearJacobian.SetZero();
			m_linearMass = 0;
			m_force = 0;
			m_angularMass = 0;
			m_torque = 0;
			m_motorJacobian.SetZero();
			m_motorMass = 0;
			m_motorForce = 0;
			m_limitForce = 0;
			m_limitPositionImpulse = 0;
			m_lowerTranslation = def.lowerTranslation;
			m_upperTranslation = def.upperTranslation;
			m_maxMotorForce = def.maxMotorForce;
			m_motorSpeed = def.motorSpeed;
			m_enableLimit = def.enableLimit;
			m_enableMotor = def.enableMotor;
		}
		override public function SolveVelocityConstraints(step:b2TimeStep):void{
			var invI1:Number;
			var oldLimitForce:Number;
			var motorCdot:Number;
			var motorForce:Number;
			var oldMotorForce:Number;
			var limitCdot:Number;
			var limitForce:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var invMass1:Number = b1.m_invMass;
			var invMass2:Number = b2.m_invMass;
			invI1 = b1.m_invI;
			var invI2:Number = b2.m_invI;
			var linearCdot:Number = m_linearJacobian.Compute(b1.m_linearVelocity, b1.m_angularVelocity, b2.m_linearVelocity, b2.m_angularVelocity);
			var force:Number = ((-(step.inv_dt) * m_linearMass) * linearCdot);
			m_force = (m_force + force);
			var P:Number = (step.dt * force);
			b1.m_linearVelocity.x = (b1.m_linearVelocity.x + ((invMass1 * P) * m_linearJacobian.linear1.x));
			b1.m_linearVelocity.y = (b1.m_linearVelocity.y + ((invMass1 * P) * m_linearJacobian.linear1.y));
			b1.m_angularVelocity = (b1.m_angularVelocity + ((invI1 * P) * m_linearJacobian.angular1));
			b2.m_linearVelocity.x = (b2.m_linearVelocity.x + ((invMass2 * P) * m_linearJacobian.linear2.x));
			b2.m_linearVelocity.y = (b2.m_linearVelocity.y + ((invMass2 * P) * m_linearJacobian.linear2.y));
			b2.m_angularVelocity = (b2.m_angularVelocity + ((invI2 * P) * m_linearJacobian.angular2));
			var angularCdot:Number = (b2.m_angularVelocity - b1.m_angularVelocity);
			var torque:Number = ((-(step.inv_dt) * m_angularMass) * angularCdot);
			m_torque = (m_torque + torque);
			var L:Number = (step.dt * torque);
			b1.m_angularVelocity = (b1.m_angularVelocity - (invI1 * L));
			b2.m_angularVelocity = (b2.m_angularVelocity + (invI2 * L));
			if (((m_enableMotor) && (!((m_limitState == e_equalLimits))))){
				motorCdot = (m_motorJacobian.Compute(b1.m_linearVelocity, b1.m_angularVelocity, b2.m_linearVelocity, b2.m_angularVelocity) - m_motorSpeed);
				motorForce = ((-(step.inv_dt) * m_motorMass) * motorCdot);
				oldMotorForce = m_motorForce;
				m_motorForce = b2Math.b2Clamp((m_motorForce + motorForce), -(m_maxMotorForce), m_maxMotorForce);
				motorForce = (m_motorForce - oldMotorForce);
				P = (step.dt * motorForce);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + ((invMass1 * P) * m_motorJacobian.linear1.x));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + ((invMass1 * P) * m_motorJacobian.linear1.y));
				b1.m_angularVelocity = (b1.m_angularVelocity + ((invI1 * P) * m_motorJacobian.angular1));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + ((invMass2 * P) * m_motorJacobian.linear2.x));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + ((invMass2 * P) * m_motorJacobian.linear2.y));
				b2.m_angularVelocity = (b2.m_angularVelocity + ((invI2 * P) * m_motorJacobian.angular2));
			};
			if (((m_enableLimit) && (!((m_limitState == e_inactiveLimit))))){
				limitCdot = m_motorJacobian.Compute(b1.m_linearVelocity, b1.m_angularVelocity, b2.m_linearVelocity, b2.m_angularVelocity);
				limitForce = ((-(step.inv_dt) * m_motorMass) * limitCdot);
				if (m_limitState == e_equalLimits){
					m_limitForce = (m_limitForce + limitForce);
				} else {
					if (m_limitState == e_atLowerLimit){
						oldLimitForce = m_limitForce;
						m_limitForce = b2Math.b2Max((m_limitForce + limitForce), 0);
						limitForce = (m_limitForce - oldLimitForce);
					} else {
						if (m_limitState == e_atUpperLimit){
							oldLimitForce = m_limitForce;
							m_limitForce = b2Math.b2Min((m_limitForce + limitForce), 0);
							limitForce = (m_limitForce - oldLimitForce);
						};
					};
				};
				P = (step.dt * limitForce);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + ((invMass1 * P) * m_motorJacobian.linear1.x));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + ((invMass1 * P) * m_motorJacobian.linear1.y));
				b1.m_angularVelocity = (b1.m_angularVelocity + ((invI1 * P) * m_motorJacobian.angular1));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + ((invMass2 * P) * m_motorJacobian.linear2.x));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + ((invMass2 * P) * m_motorJacobian.linear2.y));
				b2.m_angularVelocity = (b2.m_angularVelocity + ((invI2 * P) * m_motorJacobian.angular2));
			};
		}
		override public function GetAnchor1():b2Vec2{
			return (m_body1.GetWorldPoint(m_localAnchor1));
		}
		override public function GetAnchor2():b2Vec2{
			return (m_body2.GetWorldPoint(m_localAnchor2));
		}
		public function GetUpperLimit():Number{
			return (m_upperTranslation);
		}
		public function GetLowerLimit():Number{
			return (m_lowerTranslation);
		}
		public function EnableMotor(flag:Boolean):void{
			m_enableMotor = flag;
		}
		public function GetJointTranslation():Number{
			var tMat:b2Mat22;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var p1:b2Vec2 = b1.GetWorldPoint(m_localAnchor1);
			var p2:b2Vec2 = b2.GetWorldPoint(m_localAnchor2);
			var dX:Number = (p2.x - p1.x);
			var dY:Number = (p2.y - p1.y);
			var axis:b2Vec2 = b1.GetWorldVector(m_localXAxis1);
			var translation:Number = ((axis.x * dX) + (axis.y * dY));
			return (translation);
		}
		public function GetMotorSpeed():Number{
			return (m_motorSpeed);
		}
		override public function GetReactionForce():b2Vec2{
			var tMat:b2Mat22 = m_body1.m_xf.R;
			var ax1X:Number = (m_limitForce * ((tMat.col1.x * m_localXAxis1.x) + (tMat.col2.x * m_localXAxis1.y)));
			var ax1Y:Number = (m_limitForce * ((tMat.col1.y * m_localXAxis1.x) + (tMat.col2.y * m_localXAxis1.y)));
			var ay1X:Number = (m_force * ((tMat.col1.x * m_localYAxis1.x) + (tMat.col2.x * m_localYAxis1.y)));
			var ay1Y:Number = (m_force * ((tMat.col1.y * m_localYAxis1.x) + (tMat.col2.y * m_localYAxis1.y)));
			return (new b2Vec2(((m_limitForce * ax1X) + (m_force * ay1X)), ((m_limitForce * ax1Y) + (m_force * ay1Y))));
		}
		override public function SolvePositionConstraints():Boolean{
			var limitC:Number;
			var oldLimitImpulse:Number;
			var tMat:b2Mat22;
			var tX:Number;
			var ax1X:Number;
			var ax1Y:Number;
			var translation:Number;
			var limitImpulse:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var invMass1:Number = b1.m_invMass;
			var invMass2:Number = b2.m_invMass;
			var invI1:Number = b1.m_invI;
			var invI2:Number = b2.m_invI;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var p1X:Number = (b1.m_sweep.c.x + r1X);
			var p1Y:Number = (b1.m_sweep.c.y + r1Y);
			var p2X:Number = (b2.m_sweep.c.x + r2X);
			var p2Y:Number = (b2.m_sweep.c.y + r2Y);
			var dX:Number = (p2X - p1X);
			var dY:Number = (p2Y - p1Y);
			tMat = b1.m_xf.R;
			var ay1X:Number = ((tMat.col1.x * m_localYAxis1.x) + (tMat.col2.x * m_localYAxis1.y));
			var ay1Y:Number = ((tMat.col1.y * m_localYAxis1.x) + (tMat.col2.y * m_localYAxis1.y));
			var linearC:Number = ((ay1X * dX) + (ay1Y * dY));
			linearC = b2Math.b2Clamp(linearC, -(b2Settings.b2_maxLinearCorrection), b2Settings.b2_maxLinearCorrection);
			var linearImpulse:Number = (-(m_linearMass) * linearC);
			b1.m_sweep.c.x = (b1.m_sweep.c.x + ((invMass1 * linearImpulse) * m_linearJacobian.linear1.x));
			b1.m_sweep.c.y = (b1.m_sweep.c.y + ((invMass1 * linearImpulse) * m_linearJacobian.linear1.y));
			b1.m_sweep.a = (b1.m_sweep.a + ((invI1 * linearImpulse) * m_linearJacobian.angular1));
			b2.m_sweep.c.x = (b2.m_sweep.c.x + ((invMass2 * linearImpulse) * m_linearJacobian.linear2.x));
			b2.m_sweep.c.y = (b2.m_sweep.c.y + ((invMass2 * linearImpulse) * m_linearJacobian.linear2.y));
			b2.m_sweep.a = (b2.m_sweep.a + ((invI2 * linearImpulse) * m_linearJacobian.angular2));
			var positionError:Number = b2Math.b2Abs(linearC);
			var angularC:Number = ((b2.m_sweep.a - b1.m_sweep.a) - m_refAngle);
			angularC = b2Math.b2Clamp(angularC, -(b2Settings.b2_maxAngularCorrection), b2Settings.b2_maxAngularCorrection);
			var angularImpulse:Number = (-(m_angularMass) * angularC);
			b1.m_sweep.a = (b1.m_sweep.a - (b1.m_invI * angularImpulse));
			b2.m_sweep.a = (b2.m_sweep.a + (b2.m_invI * angularImpulse));
			b1.SynchronizeTransform();
			b2.SynchronizeTransform();
			var angularError:Number = b2Math.b2Abs(angularC);
			if (((m_enableLimit) && (!((m_limitState == e_inactiveLimit))))){
				tMat = b1.m_xf.R;
				r1X = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
				r1Y = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
				r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
				r1X = tX;
				tMat = b2.m_xf.R;
				r2X = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
				r2Y = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
				r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
				r2X = tX;
				p1X = (b1.m_sweep.c.x + r1X);
				p1Y = (b1.m_sweep.c.y + r1Y);
				p2X = (b2.m_sweep.c.x + r2X);
				p2Y = (b2.m_sweep.c.y + r2Y);
				dX = (p2X - p1X);
				dY = (p2Y - p1Y);
				tMat = b1.m_xf.R;
				ax1X = ((tMat.col1.x * m_localXAxis1.x) + (tMat.col2.x * m_localXAxis1.y));
				ax1Y = ((tMat.col1.y * m_localXAxis1.x) + (tMat.col2.y * m_localXAxis1.y));
				translation = ((ax1X * dX) + (ax1Y * dY));
				limitImpulse = 0;
				if (m_limitState == e_equalLimits){
					limitC = b2Math.b2Clamp(translation, -(b2Settings.b2_maxLinearCorrection), b2Settings.b2_maxLinearCorrection);
					limitImpulse = (-(m_motorMass) * limitC);
					positionError = b2Math.b2Max(positionError, b2Math.b2Abs(angularC));
				} else {
					if (m_limitState == e_atLowerLimit){
						limitC = (translation - m_lowerTranslation);
						positionError = b2Math.b2Max(positionError, -(limitC));
						limitC = b2Math.b2Clamp((limitC + b2Settings.b2_linearSlop), -(b2Settings.b2_maxLinearCorrection), 0);
						limitImpulse = (-(m_motorMass) * limitC);
						oldLimitImpulse = m_limitPositionImpulse;
						m_limitPositionImpulse = b2Math.b2Max((m_limitPositionImpulse + limitImpulse), 0);
						limitImpulse = (m_limitPositionImpulse - oldLimitImpulse);
					} else {
						if (m_limitState == e_atUpperLimit){
							limitC = (translation - m_upperTranslation);
							positionError = b2Math.b2Max(positionError, limitC);
							limitC = b2Math.b2Clamp((limitC - b2Settings.b2_linearSlop), 0, b2Settings.b2_maxLinearCorrection);
							limitImpulse = (-(m_motorMass) * limitC);
							oldLimitImpulse = m_limitPositionImpulse;
							m_limitPositionImpulse = b2Math.b2Min((m_limitPositionImpulse + limitImpulse), 0);
							limitImpulse = (m_limitPositionImpulse - oldLimitImpulse);
						};
					};
				};
				b1.m_sweep.c.x = (b1.m_sweep.c.x + ((invMass1 * limitImpulse) * m_motorJacobian.linear1.x));
				b1.m_sweep.c.y = (b1.m_sweep.c.y + ((invMass1 * limitImpulse) * m_motorJacobian.linear1.y));
				b1.m_sweep.a = (b1.m_sweep.a + ((invI1 * limitImpulse) * m_motorJacobian.angular1));
				b2.m_sweep.c.x = (b2.m_sweep.c.x + ((invMass2 * limitImpulse) * m_motorJacobian.linear2.x));
				b2.m_sweep.c.y = (b2.m_sweep.c.y + ((invMass2 * limitImpulse) * m_motorJacobian.linear2.y));
				b2.m_sweep.a = (b2.m_sweep.a + ((invI2 * limitImpulse) * m_motorJacobian.angular2));
				b1.SynchronizeTransform();
				b2.SynchronizeTransform();
			};
			return ((((positionError <= b2Settings.b2_linearSlop)) && ((angularError <= b2Settings.b2_angularSlop))));
		}
		public function SetMotorSpeed(speed:Number):void{
			m_motorSpeed = speed;
		}
		public function GetJointSpeed():Number{
			var tMat:b2Mat22;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var p1X:Number = (b1.m_sweep.c.x + r1X);
			var p1Y:Number = (b1.m_sweep.c.y + r1Y);
			var p2X:Number = (b2.m_sweep.c.x + r2X);
			var p2Y:Number = (b2.m_sweep.c.y + r2Y);
			var dX:Number = (p2X - p1X);
			var dY:Number = (p2Y - p1Y);
			var axis:b2Vec2 = b1.GetWorldVector(m_localXAxis1);
			var v1:b2Vec2 = b1.m_linearVelocity;
			var v2:b2Vec2 = b2.m_linearVelocity;
			var w1:Number = b1.m_angularVelocity;
			var w2:Number = b2.m_angularVelocity;
			var speed:Number = (((dX * (-(w1) * axis.y)) + (dY * (w1 * axis.x))) + ((axis.x * (((v2.x + (-(w2) * r2Y)) - v1.x) - (-(w1) * r1Y))) + (axis.y * (((v2.y + (w2 * r2X)) - v1.y) - (w1 * r1X)))));
			return (speed);
		}
		override public function InitVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var tX:Number;
			var ax1X:Number;
			var ax1Y:Number;
			var dX:Number;
			var dY:Number;
			var jointTranslation:Number;
			var P1X:Number;
			var P1Y:Number;
			var P2X:Number;
			var P2Y:Number;
			var L1:Number;
			var L2:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var invMass1:Number = b1.m_invMass;
			var invMass2:Number = b2.m_invMass;
			var invI1:Number = b1.m_invI;
			var invI2:Number = b2.m_invI;
			tMat = b1.m_xf.R;
			var ay1X:Number = ((tMat.col1.x * m_localYAxis1.x) + (tMat.col2.x * m_localYAxis1.y));
			var ay1Y:Number = ((tMat.col1.y * m_localYAxis1.x) + (tMat.col2.y * m_localYAxis1.y));
			var eX:Number = ((b2.m_sweep.c.x + r2X) - b1.m_sweep.c.x);
			var eY:Number = ((b2.m_sweep.c.y + r2Y) - b1.m_sweep.c.y);
			m_linearJacobian.linear1.x = -(ay1X);
			m_linearJacobian.linear1.y = -(ay1Y);
			m_linearJacobian.linear2.x = ay1X;
			m_linearJacobian.linear2.y = ay1Y;
			m_linearJacobian.angular1 = -(((eX * ay1Y) - (eY * ay1X)));
			m_linearJacobian.angular2 = ((r2X * ay1Y) - (r2Y * ay1X));
			m_linearMass = (((invMass1 + ((invI1 * m_linearJacobian.angular1) * m_linearJacobian.angular1)) + invMass2) + ((invI2 * m_linearJacobian.angular2) * m_linearJacobian.angular2));
			m_linearMass = (1 / m_linearMass);
			m_angularMass = (invI1 + invI2);
			if (m_angularMass > Number.MIN_VALUE){
				m_angularMass = (1 / m_angularMass);
			};
			if (((m_enableLimit) || (m_enableMotor))){
				tMat = b1.m_xf.R;
				ax1X = ((tMat.col1.x * m_localXAxis1.x) + (tMat.col2.x * m_localXAxis1.y));
				ax1Y = ((tMat.col1.y * m_localXAxis1.x) + (tMat.col2.y * m_localXAxis1.y));
				m_motorJacobian.linear1.x = -(ax1X);
				m_motorJacobian.linear1.y = -(ax1Y);
				m_motorJacobian.linear2.x = ax1X;
				m_motorJacobian.linear2.y = ax1Y;
				m_motorJacobian.angular1 = -(((eX * ax1Y) - (eY * ax1X)));
				m_motorJacobian.angular2 = ((r2X * ax1Y) - (r2Y * ax1X));
				m_motorMass = (((invMass1 + ((invI1 * m_motorJacobian.angular1) * m_motorJacobian.angular1)) + invMass2) + ((invI2 * m_motorJacobian.angular2) * m_motorJacobian.angular2));
				m_motorMass = (1 / m_motorMass);
				if (m_enableLimit){
					dX = (eX - r1X);
					dY = (eY - r1Y);
					jointTranslation = ((ax1X * dX) + (ax1Y * dY));
					if (b2Math.b2Abs((m_upperTranslation - m_lowerTranslation)) < (2 * b2Settings.b2_linearSlop)){
						m_limitState = e_equalLimits;
					} else {
						if (jointTranslation <= m_lowerTranslation){
							if (m_limitState != e_atLowerLimit){
								m_limitForce = 0;
							};
							m_limitState = e_atLowerLimit;
						} else {
							if (jointTranslation >= m_upperTranslation){
								if (m_limitState != e_atUpperLimit){
									m_limitForce = 0;
								};
								m_limitState = e_atUpperLimit;
							} else {
								m_limitState = e_inactiveLimit;
								m_limitForce = 0;
							};
						};
					};
				};
			};
			if (m_enableMotor == false){
				m_motorForce = 0;
			};
			if (m_enableLimit == false){
				m_limitForce = 0;
			};
			if (step.warmStarting){
				P1X = (step.dt * ((m_force * m_linearJacobian.linear1.x) + ((m_motorForce + m_limitForce) * m_motorJacobian.linear1.x)));
				P1Y = (step.dt * ((m_force * m_linearJacobian.linear1.y) + ((m_motorForce + m_limitForce) * m_motorJacobian.linear1.y)));
				P2X = (step.dt * ((m_force * m_linearJacobian.linear2.x) + ((m_motorForce + m_limitForce) * m_motorJacobian.linear2.x)));
				P2Y = (step.dt * ((m_force * m_linearJacobian.linear2.y) + ((m_motorForce + m_limitForce) * m_motorJacobian.linear2.y)));
				L1 = (step.dt * (((m_force * m_linearJacobian.angular1) - m_torque) + ((m_motorForce + m_limitForce) * m_motorJacobian.angular1)));
				L2 = (step.dt * (((m_force * m_linearJacobian.angular2) + m_torque) + ((m_motorForce + m_limitForce) * m_motorJacobian.angular2)));
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + (invMass1 * P1X));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + (invMass1 * P1Y));
				b1.m_angularVelocity = (b1.m_angularVelocity + (invI1 * L1));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (invMass2 * P2X));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (invMass2 * P2Y));
				b2.m_angularVelocity = (b2.m_angularVelocity + (invI2 * L2));
			} else {
				m_force = 0;
				m_torque = 0;
				m_limitForce = 0;
				m_motorForce = 0;
			};
			m_limitPositionImpulse = 0;
		}
		public function GetMotorForce():Number{
			return (m_motorForce);
		}
		public function EnableLimit(flag:Boolean):void{
			m_enableLimit = flag;
		}
		public function SetMaxMotorForce(force:Number):void{
			m_maxMotorForce = force;
		}
		override public function GetReactionTorque():Number{
			return (m_torque);
		}
		public function IsLimitEnabled():Boolean{
			return (m_enableLimit);
		}
		public function IsMotorEnabled():Boolean{
			return (m_enableMotor);
		}
		public function SetLimits(lower:Number, upper:Number):void{
			m_lowerTranslation = lower;
			m_upperTranslation = upper;
		}

	}
}//package Box2D.Dynamics.Joints 
Section 70
//b2PrismaticJointDef (Box2D.Dynamics.Joints.b2PrismaticJointDef)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;

	public class b2PrismaticJointDef extends b2JointDef {

		public var motorSpeed:Number;
		public var localAxis1:b2Vec2;
		public var referenceAngle:Number;
		public var upperTranslation:Number;
		public var localAnchor1:b2Vec2;
		public var localAnchor2:b2Vec2;
		public var enableLimit:Boolean;
		public var enableMotor:Boolean;
		public var maxMotorForce:Number;
		public var lowerTranslation:Number;

		public function b2PrismaticJointDef(){
			localAnchor1 = new b2Vec2();
			localAnchor2 = new b2Vec2();
			localAxis1 = new b2Vec2();
			super();
			type = b2Joint.e_prismaticJoint;
			localAxis1.Set(1, 0);
			referenceAngle = 0;
			enableLimit = false;
			lowerTranslation = 0;
			upperTranslation = 0;
			enableMotor = false;
			maxMotorForce = 0;
			motorSpeed = 0;
		}
		public function Initialize(b1:b2Body, b2:b2Body, anchor:b2Vec2, axis:b2Vec2):void{
			body1 = b1;
			body2 = b2;
			localAnchor1 = body1.GetLocalPoint(anchor);
			localAnchor2 = body2.GetLocalPoint(anchor);
			localAxis1 = body1.GetLocalVector(axis);
			referenceAngle = (body2.GetAngle() - body1.GetAngle());
		}

	}
}//package Box2D.Dynamics.Joints 
Section 71
//b2PulleyJoint (Box2D.Dynamics.Joints.b2PulleyJoint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2PulleyJoint extends b2Joint {

		public var m_limitState1:int;
		public var m_limitState2:int;
		public var m_ground:b2Body;
		public var m_maxLength2:Number;
		public var m_maxLength1:Number;
		public var m_limitPositionImpulse1:Number;
		public var m_limitPositionImpulse2:Number;
		public var m_force:Number;
		public var m_constant:Number;
		public var m_positionImpulse:Number;
		public var m_state:int;
		public var m_ratio:Number;
		public var m_groundAnchor1:b2Vec2;
		public var m_groundAnchor2:b2Vec2;
		public var m_localAnchor1:b2Vec2;
		public var m_localAnchor2:b2Vec2;
		public var m_limitMass1:Number;
		public var m_limitMass2:Number;
		public var m_pulleyMass:Number;
		public var m_u1:b2Vec2;
		public var m_limitForce1:Number;
		public var m_limitForce2:Number;
		public var m_u2:b2Vec2;

		public static const b2_minPulleyLength:Number = 2;

		public function b2PulleyJoint(def:b2PulleyJointDef){
			var tMat:b2Mat22;
			var tX:Number;
			var tY:Number;
			m_groundAnchor1 = new b2Vec2();
			m_groundAnchor2 = new b2Vec2();
			m_localAnchor1 = new b2Vec2();
			m_localAnchor2 = new b2Vec2();
			m_u1 = new b2Vec2();
			m_u2 = new b2Vec2();
			super(def);
			m_ground = m_body1.m_world.m_groundBody;
			m_groundAnchor1.x = (def.groundAnchor1.x - m_ground.m_xf.position.x);
			m_groundAnchor1.y = (def.groundAnchor1.y - m_ground.m_xf.position.y);
			m_groundAnchor2.x = (def.groundAnchor2.x - m_ground.m_xf.position.x);
			m_groundAnchor2.y = (def.groundAnchor2.y - m_ground.m_xf.position.y);
			m_localAnchor1.SetV(def.localAnchor1);
			m_localAnchor2.SetV(def.localAnchor2);
			m_ratio = def.ratio;
			m_constant = (def.length1 + (m_ratio * def.length2));
			m_maxLength1 = b2Math.b2Min(def.maxLength1, (m_constant - (m_ratio * b2_minPulleyLength)));
			m_maxLength2 = b2Math.b2Min(def.maxLength2, ((m_constant - b2_minPulleyLength) / m_ratio));
			m_force = 0;
			m_limitForce1 = 0;
			m_limitForce2 = 0;
		}
		public function GetGroundAnchor2():b2Vec2{
			var a:b2Vec2 = m_ground.m_xf.position.Copy();
			a.Add(m_groundAnchor2);
			return (a);
		}
		override public function GetAnchor1():b2Vec2{
			return (m_body1.GetWorldPoint(m_localAnchor1));
		}
		override public function GetAnchor2():b2Vec2{
			return (m_body2.GetWorldPoint(m_localAnchor2));
		}
		override public function GetReactionForce():b2Vec2{
			var F:b2Vec2 = m_u2.Copy();
			F.Multiply(m_force);
			return (F);
		}
		override public function SolvePositionConstraints():Boolean{
			var tMat:b2Mat22;
			var r1X:Number;
			var r1Y:Number;
			var r2X:Number;
			var r2Y:Number;
			var p1X:Number;
			var p1Y:Number;
			var p2X:Number;
			var p2Y:Number;
			var length1:Number;
			var length2:Number;
			var C:Number;
			var impulse:Number;
			var oldImpulse:Number;
			var oldLimitPositionImpulse:Number;
			var tX:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var s1X:Number = (m_ground.m_xf.position.x + m_groundAnchor1.x);
			var s1Y:Number = (m_ground.m_xf.position.y + m_groundAnchor1.y);
			var s2X:Number = (m_ground.m_xf.position.x + m_groundAnchor2.x);
			var s2Y:Number = (m_ground.m_xf.position.y + m_groundAnchor2.y);
			var linearError:Number = 0;
			if (m_state == e_atUpperLimit){
				tMat = b1.m_xf.R;
				r1X = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
				r1Y = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
				r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
				r1X = tX;
				tMat = b2.m_xf.R;
				r2X = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
				r2Y = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
				r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
				r2X = tX;
				p1X = (b1.m_sweep.c.x + r1X);
				p1Y = (b1.m_sweep.c.y + r1Y);
				p2X = (b2.m_sweep.c.x + r2X);
				p2Y = (b2.m_sweep.c.y + r2Y);
				m_u1.Set((p1X - s1X), (p1Y - s1Y));
				m_u2.Set((p2X - s2X), (p2Y - s2Y));
				length1 = m_u1.Length();
				length2 = m_u2.Length();
				if (length1 > b2Settings.b2_linearSlop){
					m_u1.Multiply((1 / length1));
				} else {
					m_u1.SetZero();
				};
				if (length2 > b2Settings.b2_linearSlop){
					m_u2.Multiply((1 / length2));
				} else {
					m_u2.SetZero();
				};
				C = ((m_constant - length1) - (m_ratio * length2));
				linearError = b2Math.b2Max(linearError, -(C));
				C = b2Math.b2Clamp((C + b2Settings.b2_linearSlop), -(b2Settings.b2_maxLinearCorrection), 0);
				impulse = (-(m_pulleyMass) * C);
				oldImpulse = m_positionImpulse;
				m_positionImpulse = b2Math.b2Max(0, (m_positionImpulse + impulse));
				impulse = (m_positionImpulse - oldImpulse);
				p1X = (-(impulse) * m_u1.x);
				p1Y = (-(impulse) * m_u1.y);
				p2X = ((-(m_ratio) * impulse) * m_u2.x);
				p2Y = ((-(m_ratio) * impulse) * m_u2.y);
				b1.m_sweep.c.x = (b1.m_sweep.c.x + (b1.m_invMass * p1X));
				b1.m_sweep.c.y = (b1.m_sweep.c.y + (b1.m_invMass * p1Y));
				b1.m_sweep.a = (b1.m_sweep.a + (b1.m_invI * ((r1X * p1Y) - (r1Y * p1X))));
				b2.m_sweep.c.x = (b2.m_sweep.c.x + (b2.m_invMass * p2X));
				b2.m_sweep.c.y = (b2.m_sweep.c.y + (b2.m_invMass * p2Y));
				b2.m_sweep.a = (b2.m_sweep.a + (b2.m_invI * ((r2X * p2Y) - (r2Y * p2X))));
				b1.SynchronizeTransform();
				b2.SynchronizeTransform();
			};
			if (m_limitState1 == e_atUpperLimit){
				tMat = b1.m_xf.R;
				r1X = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
				r1Y = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
				r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
				r1X = tX;
				p1X = (b1.m_sweep.c.x + r1X);
				p1Y = (b1.m_sweep.c.y + r1Y);
				m_u1.Set((p1X - s1X), (p1Y - s1Y));
				length1 = m_u1.Length();
				if (length1 > b2Settings.b2_linearSlop){
					m_u1.x = (m_u1.x * (1 / length1));
					m_u1.y = (m_u1.y * (1 / length1));
				} else {
					m_u1.SetZero();
				};
				C = (m_maxLength1 - length1);
				linearError = b2Math.b2Max(linearError, -(C));
				C = b2Math.b2Clamp((C + b2Settings.b2_linearSlop), -(b2Settings.b2_maxLinearCorrection), 0);
				impulse = (-(m_limitMass1) * C);
				oldLimitPositionImpulse = m_limitPositionImpulse1;
				m_limitPositionImpulse1 = b2Math.b2Max(0, (m_limitPositionImpulse1 + impulse));
				impulse = (m_limitPositionImpulse1 - oldLimitPositionImpulse);
				p1X = (-(impulse) * m_u1.x);
				p1Y = (-(impulse) * m_u1.y);
				b1.m_sweep.c.x = (b1.m_sweep.c.x + (b1.m_invMass * p1X));
				b1.m_sweep.c.y = (b1.m_sweep.c.y + (b1.m_invMass * p1Y));
				b1.m_sweep.a = (b1.m_sweep.a + (b1.m_invI * ((r1X * p1Y) - (r1Y * p1X))));
				b1.SynchronizeTransform();
			};
			if (m_limitState2 == e_atUpperLimit){
				tMat = b2.m_xf.R;
				r2X = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
				r2Y = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
				tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
				r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
				r2X = tX;
				p2X = (b2.m_sweep.c.x + r2X);
				p2Y = (b2.m_sweep.c.y + r2Y);
				m_u2.Set((p2X - s2X), (p2Y - s2Y));
				length2 = m_u2.Length();
				if (length2 > b2Settings.b2_linearSlop){
					m_u2.x = (m_u2.x * (1 / length2));
					m_u2.y = (m_u2.y * (1 / length2));
				} else {
					m_u2.SetZero();
				};
				C = (m_maxLength2 - length2);
				linearError = b2Math.b2Max(linearError, -(C));
				C = b2Math.b2Clamp((C + b2Settings.b2_linearSlop), -(b2Settings.b2_maxLinearCorrection), 0);
				impulse = (-(m_limitMass2) * C);
				oldLimitPositionImpulse = m_limitPositionImpulse2;
				m_limitPositionImpulse2 = b2Math.b2Max(0, (m_limitPositionImpulse2 + impulse));
				impulse = (m_limitPositionImpulse2 - oldLimitPositionImpulse);
				p2X = (-(impulse) * m_u2.x);
				p2Y = (-(impulse) * m_u2.y);
				b2.m_sweep.c.x = (b2.m_sweep.c.x + (b2.m_invMass * p2X));
				b2.m_sweep.c.y = (b2.m_sweep.c.y + (b2.m_invMass * p2Y));
				b2.m_sweep.a = (b2.m_sweep.a + (b2.m_invI * ((r2X * p2Y) - (r2Y * p2X))));
				b2.SynchronizeTransform();
			};
			return ((linearError < b2Settings.b2_linearSlop));
		}
		override public function InitVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var P1X:Number;
			var P1Y:Number;
			var P2X:Number;
			var P2Y:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var p1X:Number = (b1.m_sweep.c.x + r1X);
			var p1Y:Number = (b1.m_sweep.c.y + r1Y);
			var p2X:Number = (b2.m_sweep.c.x + r2X);
			var p2Y:Number = (b2.m_sweep.c.y + r2Y);
			var s1X:Number = (m_ground.m_xf.position.x + m_groundAnchor1.x);
			var s1Y:Number = (m_ground.m_xf.position.y + m_groundAnchor1.y);
			var s2X:Number = (m_ground.m_xf.position.x + m_groundAnchor2.x);
			var s2Y:Number = (m_ground.m_xf.position.y + m_groundAnchor2.y);
			m_u1.Set((p1X - s1X), (p1Y - s1Y));
			m_u2.Set((p2X - s2X), (p2Y - s2Y));
			var length1:Number = m_u1.Length();
			var length2:Number = m_u2.Length();
			if (length1 > b2Settings.b2_linearSlop){
				m_u1.Multiply((1 / length1));
			} else {
				m_u1.SetZero();
			};
			if (length2 > b2Settings.b2_linearSlop){
				m_u2.Multiply((1 / length2));
			} else {
				m_u2.SetZero();
			};
			var C:Number = ((m_constant - length1) - (m_ratio * length2));
			if (C > 0){
				m_state = e_inactiveLimit;
				m_force = 0;
			} else {
				m_state = e_atUpperLimit;
				m_positionImpulse = 0;
			};
			if (length1 < m_maxLength1){
				m_limitState1 = e_inactiveLimit;
				m_limitForce1 = 0;
			} else {
				m_limitState1 = e_atUpperLimit;
				m_limitPositionImpulse1 = 0;
			};
			if (length2 < m_maxLength2){
				m_limitState2 = e_inactiveLimit;
				m_limitForce2 = 0;
			} else {
				m_limitState2 = e_atUpperLimit;
				m_limitPositionImpulse2 = 0;
			};
			var cr1u1:Number = ((r1X * m_u1.y) - (r1Y * m_u1.x));
			var cr2u2:Number = ((r2X * m_u2.y) - (r2Y * m_u2.x));
			m_limitMass1 = (b1.m_invMass + ((b1.m_invI * cr1u1) * cr1u1));
			m_limitMass2 = (b2.m_invMass + ((b2.m_invI * cr2u2) * cr2u2));
			m_pulleyMass = (m_limitMass1 + ((m_ratio * m_ratio) * m_limitMass2));
			m_limitMass1 = (1 / m_limitMass1);
			m_limitMass2 = (1 / m_limitMass2);
			m_pulleyMass = (1 / m_pulleyMass);
			if (step.warmStarting){
				P1X = ((step.dt * (-(m_force) - m_limitForce1)) * m_u1.x);
				P1Y = ((step.dt * (-(m_force) - m_limitForce1)) * m_u1.y);
				P2X = ((step.dt * ((-(m_ratio) * m_force) - m_limitForce2)) * m_u2.x);
				P2Y = ((step.dt * ((-(m_ratio) * m_force) - m_limitForce2)) * m_u2.y);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + (b1.m_invMass * P1X));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + (b1.m_invMass * P1Y));
				b1.m_angularVelocity = (b1.m_angularVelocity + (b1.m_invI * ((r1X * P1Y) - (r1Y * P1X))));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (b2.m_invMass * P2X));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (b2.m_invMass * P2Y));
				b2.m_angularVelocity = (b2.m_angularVelocity + (b2.m_invI * ((r2X * P2Y) - (r2Y * P2X))));
			} else {
				m_force = 0;
				m_limitForce1 = 0;
				m_limitForce2 = 0;
			};
		}
		override public function GetReactionTorque():Number{
			return (0);
		}
		public function GetRatio():Number{
			return (m_ratio);
		}
		override public function SolveVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var r2X:Number;
			var v1X:Number;
			var v1Y:Number;
			var v2X:Number;
			var v2Y:Number;
			var P1X:Number;
			var P1Y:Number;
			var P2X:Number;
			var P2Y:Number;
			var Cdot:Number;
			var force:Number;
			var oldForce:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			r2X = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			if (m_state == e_atUpperLimit){
				v1X = (b1.m_linearVelocity.x + (-(b1.m_angularVelocity) * r1Y));
				v1Y = (b1.m_linearVelocity.y + (b1.m_angularVelocity * r1X));
				v2X = (b2.m_linearVelocity.x + (-(b2.m_angularVelocity) * r2Y));
				v2Y = (b2.m_linearVelocity.y + (b2.m_angularVelocity * r2X));
				Cdot = (-(((m_u1.x * v1X) + (m_u1.y * v1Y))) - (m_ratio * ((m_u2.x * v2X) + (m_u2.y * v2Y))));
				force = ((-(step.inv_dt) * m_pulleyMass) * Cdot);
				oldForce = m_force;
				m_force = b2Math.b2Max(0, (m_force + force));
				force = (m_force - oldForce);
				P1X = ((-(step.dt) * force) * m_u1.x);
				P1Y = ((-(step.dt) * force) * m_u1.y);
				P2X = (((-(step.dt) * m_ratio) * force) * m_u2.x);
				P2Y = (((-(step.dt) * m_ratio) * force) * m_u2.y);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + (b1.m_invMass * P1X));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + (b1.m_invMass * P1Y));
				b1.m_angularVelocity = (b1.m_angularVelocity + (b1.m_invI * ((r1X * P1Y) - (r1Y * P1X))));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (b2.m_invMass * P2X));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (b2.m_invMass * P2Y));
				b2.m_angularVelocity = (b2.m_angularVelocity + (b2.m_invI * ((r2X * P2Y) - (r2Y * P2X))));
			};
			if (m_limitState1 == e_atUpperLimit){
				v1X = (b1.m_linearVelocity.x + (-(b1.m_angularVelocity) * r1Y));
				v1Y = (b1.m_linearVelocity.y + (b1.m_angularVelocity * r1X));
				Cdot = -(((m_u1.x * v1X) + (m_u1.y * v1Y)));
				force = ((-(step.inv_dt) * m_limitMass1) * Cdot);
				oldForce = m_limitForce1;
				m_limitForce1 = b2Math.b2Max(0, (m_limitForce1 + force));
				force = (m_limitForce1 - oldForce);
				P1X = ((-(step.dt) * force) * m_u1.x);
				P1Y = ((-(step.dt) * force) * m_u1.y);
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x + (b1.m_invMass * P1X));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y + (b1.m_invMass * P1Y));
				b1.m_angularVelocity = (b1.m_angularVelocity + (b1.m_invI * ((r1X * P1Y) - (r1Y * P1X))));
			};
			if (m_limitState2 == e_atUpperLimit){
				v2X = (b2.m_linearVelocity.x + (-(b2.m_angularVelocity) * r2Y));
				v2Y = (b2.m_linearVelocity.y + (b2.m_angularVelocity * r2X));
				Cdot = -(((m_u2.x * v2X) + (m_u2.y * v2Y)));
				force = ((-(step.inv_dt) * m_limitMass2) * Cdot);
				oldForce = m_limitForce2;
				m_limitForce2 = b2Math.b2Max(0, (m_limitForce2 + force));
				force = (m_limitForce2 - oldForce);
				P2X = ((-(step.dt) * force) * m_u2.x);
				P2Y = ((-(step.dt) * force) * m_u2.y);
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (b2.m_invMass * P2X));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (b2.m_invMass * P2Y));
				b2.m_angularVelocity = (b2.m_angularVelocity + (b2.m_invI * ((r2X * P2Y) - (r2Y * P2X))));
			};
		}
		public function GetLength1():Number{
			var p:b2Vec2 = m_body1.GetWorldPoint(m_localAnchor1);
			var sX:Number = (m_ground.m_xf.position.x + m_groundAnchor1.x);
			var sY:Number = (m_ground.m_xf.position.y + m_groundAnchor1.y);
			var dX:Number = (p.x - sX);
			var dY:Number = (p.y - sY);
			return (Math.sqrt(((dX * dX) + (dY * dY))));
		}
		public function GetLength2():Number{
			var p:b2Vec2 = m_body2.GetWorldPoint(m_localAnchor2);
			var sX:Number = (m_ground.m_xf.position.x + m_groundAnchor2.x);
			var sY:Number = (m_ground.m_xf.position.y + m_groundAnchor2.y);
			var dX:Number = (p.x - sX);
			var dY:Number = (p.y - sY);
			return (Math.sqrt(((dX * dX) + (dY * dY))));
		}
		public function GetGroundAnchor1():b2Vec2{
			var a:b2Vec2 = m_ground.m_xf.position.Copy();
			a.Add(m_groundAnchor1);
			return (a);
		}

	}
}//package Box2D.Dynamics.Joints 
Section 72
//b2PulleyJointDef (Box2D.Dynamics.Joints.b2PulleyJointDef)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;

	public class b2PulleyJointDef extends b2JointDef {

		public var maxLength1:Number;
		public var maxLength2:Number;
		public var length1:Number;
		public var localAnchor1:b2Vec2;
		public var localAnchor2:b2Vec2;
		public var groundAnchor1:b2Vec2;
		public var groundAnchor2:b2Vec2;
		public var ratio:Number;
		public var length2:Number;

		public function b2PulleyJointDef(){
			groundAnchor1 = new b2Vec2();
			groundAnchor2 = new b2Vec2();
			localAnchor1 = new b2Vec2();
			localAnchor2 = new b2Vec2();
			super();
			type = b2Joint.e_pulleyJoint;
			groundAnchor1.Set(-1, 1);
			groundAnchor2.Set(1, 1);
			localAnchor1.Set(-1, 0);
			localAnchor2.Set(1, 0);
			length1 = 0;
			maxLength1 = 0;
			length2 = 0;
			maxLength2 = 0;
			ratio = 1;
			collideConnected = true;
		}
		public function Initialize(b1:b2Body, b2:b2Body, ga1:b2Vec2, ga2:b2Vec2, anchor1:b2Vec2, anchor2:b2Vec2, r:Number):void{
			body1 = b1;
			body2 = b2;
			groundAnchor1.SetV(ga1);
			groundAnchor2.SetV(ga2);
			localAnchor1 = body1.GetLocalPoint(anchor1);
			localAnchor2 = body2.GetLocalPoint(anchor2);
			var d1X:Number = (anchor1.x - ga1.x);
			var d1Y:Number = (anchor1.y - ga1.y);
			length1 = Math.sqrt(((d1X * d1X) + (d1Y * d1Y)));
			var d2X:Number = (anchor2.x - ga2.x);
			var d2Y:Number = (anchor2.y - ga2.y);
			length2 = Math.sqrt(((d2X * d2X) + (d2Y * d2Y)));
			ratio = r;
			var C:Number = (length1 + (ratio * length2));
			maxLength1 = (C - (ratio * b2PulleyJoint.b2_minPulleyLength));
			maxLength2 = ((C - b2PulleyJoint.b2_minPulleyLength) / ratio);
		}

	}
}//package Box2D.Dynamics.Joints 
Section 73
//b2RevoluteJoint (Box2D.Dynamics.Joints.b2RevoluteJoint)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;
	import Box2D.Common.*;

	public class b2RevoluteJoint extends b2Joint {

		public var m_limitForce:Number;
		public var m_pivotMass:b2Mat22;
		public var m_motorForce:Number;
		public var m_enableLimit:Boolean;
		public var m_limitState:int;
		public var m_motorMass:Number;
		public var m_localAnchor1:b2Vec2;
		public var m_localAnchor2:b2Vec2;
		private var K1:b2Mat22;
		private var K2:b2Mat22;
		private var K3:b2Mat22;
		private var K:b2Mat22;
		public var m_pivotForce:b2Vec2;
		public var m_enableMotor:Boolean;
		public var m_referenceAngle:Number;
		public var m_limitPositionImpulse:Number;
		public var m_motorSpeed:Number;
		public var m_upperAngle:Number;
		public var m_lowerAngle:Number;
		public var m_maxMotorTorque:Number;

		public static var tImpulse:b2Vec2 = new b2Vec2();

		public function b2RevoluteJoint(def:b2RevoluteJointDef){
			K = new b2Mat22();
			K1 = new b2Mat22();
			K2 = new b2Mat22();
			K3 = new b2Mat22();
			m_localAnchor1 = new b2Vec2();
			m_localAnchor2 = new b2Vec2();
			m_pivotForce = new b2Vec2();
			m_pivotMass = new b2Mat22();
			super(def);
			m_localAnchor1.SetV(def.localAnchor1);
			m_localAnchor2.SetV(def.localAnchor2);
			m_referenceAngle = def.referenceAngle;
			m_pivotForce.Set(0, 0);
			m_motorForce = 0;
			m_limitForce = 0;
			m_limitPositionImpulse = 0;
			m_lowerAngle = def.lowerAngle;
			m_upperAngle = def.upperAngle;
			m_maxMotorTorque = def.maxMotorTorque;
			m_motorSpeed = def.motorSpeed;
			m_enableLimit = def.enableLimit;
			m_enableMotor = def.enableMotor;
		}
		override public function SolveVelocityConstraints(step:b2TimeStep):void{
			var tMat:b2Mat22;
			var tX:Number;
			var oldLimitForce:Number;
			var PY:Number;
			var motorCdot:Number;
			var motorForce:Number;
			var oldMotorForce:Number;
			var limitCdot:Number;
			var limitForce:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var pivotCdotX:Number = (((b2.m_linearVelocity.x + (-(b2.m_angularVelocity) * r2Y)) - b1.m_linearVelocity.x) - (-(b1.m_angularVelocity) * r1Y));
			var pivotCdotY:Number = (((b2.m_linearVelocity.y + (b2.m_angularVelocity * r2X)) - b1.m_linearVelocity.y) - (b1.m_angularVelocity * r1X));
			var pivotForceX:Number = (-(step.inv_dt) * ((m_pivotMass.col1.x * pivotCdotX) + (m_pivotMass.col2.x * pivotCdotY)));
			var pivotForceY:Number = (-(step.inv_dt) * ((m_pivotMass.col1.y * pivotCdotX) + (m_pivotMass.col2.y * pivotCdotY)));
			m_pivotForce.x = (m_pivotForce.x + pivotForceX);
			m_pivotForce.y = (m_pivotForce.y + pivotForceY);
			var PX:Number = (step.dt * pivotForceX);
			PY = (step.dt * pivotForceY);
			b1.m_linearVelocity.x = (b1.m_linearVelocity.x - (b1.m_invMass * PX));
			b1.m_linearVelocity.y = (b1.m_linearVelocity.y - (b1.m_invMass * PY));
			b1.m_angularVelocity = (b1.m_angularVelocity - (b1.m_invI * ((r1X * PY) - (r1Y * PX))));
			b2.m_linearVelocity.x = (b2.m_linearVelocity.x + (b2.m_invMass * PX));
			b2.m_linearVelocity.y = (b2.m_linearVelocity.y + (b2.m_invMass * PY));
			b2.m_angularVelocity = (b2.m_angularVelocity + (b2.m_invI * ((r2X * PY) - (r2Y * PX))));
			if (((m_enableMotor) && (!((m_limitState == e_equalLimits))))){
				motorCdot = ((b2.m_angularVelocity - b1.m_angularVelocity) - m_motorSpeed);
				motorForce = ((-(step.inv_dt) * m_motorMass) * motorCdot);
				oldMotorForce = m_motorForce;
				m_motorForce = b2Math.b2Clamp((m_motorForce + motorForce), -(m_maxMotorTorque), m_maxMotorTorque);
				motorForce = (m_motorForce - oldMotorForce);
				b1.m_angularVelocity = (b1.m_angularVelocity - ((b1.m_invI * step.dt) * motorForce));
				b2.m_angularVelocity = (b2.m_angularVelocity + ((b2.m_invI * step.dt) * motorForce));
			};
			if (((m_enableLimit) && (!((m_limitState == e_inactiveLimit))))){
				limitCdot = (b2.m_angularVelocity - b1.m_angularVelocity);
				limitForce = ((-(step.inv_dt) * m_motorMass) * limitCdot);
				if (m_limitState == e_equalLimits){
					m_limitForce = (m_limitForce + limitForce);
				} else {
					if (m_limitState == e_atLowerLimit){
						oldLimitForce = m_limitForce;
						m_limitForce = b2Math.b2Max((m_limitForce + limitForce), 0);
						limitForce = (m_limitForce - oldLimitForce);
					} else {
						if (m_limitState == e_atUpperLimit){
							oldLimitForce = m_limitForce;
							m_limitForce = b2Math.b2Min((m_limitForce + limitForce), 0);
							limitForce = (m_limitForce - oldLimitForce);
						};
					};
				};
				b1.m_angularVelocity = (b1.m_angularVelocity - ((b1.m_invI * step.dt) * limitForce));
				b2.m_angularVelocity = (b2.m_angularVelocity + ((b2.m_invI * step.dt) * limitForce));
			};
		}
		override public function GetAnchor1():b2Vec2{
			return (m_body1.GetWorldPoint(m_localAnchor1));
		}
		override public function GetAnchor2():b2Vec2{
			return (m_body2.GetWorldPoint(m_localAnchor2));
		}
		public function GetUpperLimit():Number{
			return (m_upperAngle);
		}
		public function GetLowerLimit():Number{
			return (m_lowerAngle);
		}
		public function EnableMotor(flag:Boolean):void{
			m_enableMotor = flag;
		}
		public function GetMotorSpeed():Number{
			return (m_motorSpeed);
		}
		override public function GetReactionForce():b2Vec2{
			return (m_pivotForce);
		}
		override public function SolvePositionConstraints():Boolean{
			var oldLimitImpulse:Number;
			var limitC:Number;
			var tMat:b2Mat22;
			var angle:Number;
			var limitImpulse:Number;
			var b1:b2Body = m_body1;
			var b2:b2Body = m_body2;
			var positionError:Number = 0;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			var r1Y:Number = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			var tX:Number = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var p1X:Number = (b1.m_sweep.c.x + r1X);
			var p1Y:Number = (b1.m_sweep.c.y + r1Y);
			var p2X:Number = (b2.m_sweep.c.x + r2X);
			var p2Y:Number = (b2.m_sweep.c.y + r2Y);
			var ptpCX:Number = (p2X - p1X);
			var ptpCY:Number = (p2Y - p1Y);
			positionError = Math.sqrt(((ptpCX * ptpCX) + (ptpCY * ptpCY)));
			var invMass1:Number = b1.m_invMass;
			var invMass2:Number = b2.m_invMass;
			var invI1:Number = b1.m_invI;
			var invI2:Number = b2.m_invI;
			K1.col1.x = (invMass1 + invMass2);
			K1.col2.x = 0;
			K1.col1.y = 0;
			K1.col2.y = (invMass1 + invMass2);
			K2.col1.x = ((invI1 * r1Y) * r1Y);
			K2.col2.x = ((-(invI1) * r1X) * r1Y);
			K2.col1.y = ((-(invI1) * r1X) * r1Y);
			K2.col2.y = ((invI1 * r1X) * r1X);
			K3.col1.x = ((invI2 * r2Y) * r2Y);
			K3.col2.x = ((-(invI2) * r2X) * r2Y);
			K3.col1.y = ((-(invI2) * r2X) * r2Y);
			K3.col2.y = ((invI2 * r2X) * r2X);
			K.SetM(K1);
			K.AddM(K2);
			K.AddM(K3);
			K.Solve(tImpulse, -(ptpCX), -(ptpCY));
			var impulseX:Number = tImpulse.x;
			var impulseY:Number = tImpulse.y;
			b1.m_sweep.c.x = (b1.m_sweep.c.x - (b1.m_invMass * impulseX));
			b1.m_sweep.c.y = (b1.m_sweep.c.y - (b1.m_invMass * impulseY));
			b1.m_sweep.a = (b1.m_sweep.a - (b1.m_invI * ((r1X * impulseY) - (r1Y * impulseX))));
			b2.m_sweep.c.x = (b2.m_sweep.c.x + (b2.m_invMass * impulseX));
			b2.m_sweep.c.y = (b2.m_sweep.c.y + (b2.m_invMass * impulseY));
			b2.m_sweep.a = (b2.m_sweep.a + (b2.m_invI * ((r2X * impulseY) - (r2Y * impulseX))));
			b1.SynchronizeTransform();
			b2.SynchronizeTransform();
			var angularError:Number = 0;
			if (((m_enableLimit) && (!((m_limitState == e_inactiveLimit))))){
				angle = ((b2.m_sweep.a - b1.m_sweep.a) - m_referenceAngle);
				limitImpulse = 0;
				if (m_limitState == e_equalLimits){
					limitC = b2Math.b2Clamp(angle, -(b2Settings.b2_maxAngularCorrection), b2Settings.b2_maxAngularCorrection);
					limitImpulse = (-(m_motorMass) * limitC);
					angularError = b2Math.b2Abs(limitC);
				} else {
					if (m_limitState == e_atLowerLimit){
						limitC = (angle - m_lowerAngle);
						angularError = b2Math.b2Max(0, -(limitC));
						limitC = b2Math.b2Clamp((limitC + b2Settings.b2_angularSlop), -(b2Settings.b2_maxAngularCorrection), 0);
						limitImpulse = (-(m_motorMass) * limitC);
						oldLimitImpulse = m_limitPositionImpulse;
						m_limitPositionImpulse = b2Math.b2Max((m_limitPositionImpulse + limitImpulse), 0);
						limitImpulse = (m_limitPositionImpulse - oldLimitImpulse);
					} else {
						if (m_limitState == e_atUpperLimit){
							limitC = (angle - m_upperAngle);
							angularError = b2Math.b2Max(0, limitC);
							limitC = b2Math.b2Clamp((limitC - b2Settings.b2_angularSlop), 0, b2Settings.b2_maxAngularCorrection);
							limitImpulse = (-(m_motorMass) * limitC);
							oldLimitImpulse = m_limitPositionImpulse;
							m_limitPositionImpulse = b2Math.b2Min((m_limitPositionImpulse + limitImpulse), 0);
							limitImpulse = (m_limitPositionImpulse - oldLimitImpulse);
						};
					};
				};
				b1.m_sweep.a = (b1.m_sweep.a - (b1.m_invI * limitImpulse));
				b2.m_sweep.a = (b2.m_sweep.a + (b2.m_invI * limitImpulse));
				b1.SynchronizeTransform();
				b2.SynchronizeTransform();
			};
			return ((((positionError <= b2Settings.b2_linearSlop)) && ((angularError <= b2Settings.b2_angularSlop))));
		}
		public function SetMotorSpeed(speed:Number):void{
			m_motorSpeed = speed;
		}
		public function GetJointSpeed():Number{
			return ((m_body2.m_angularVelocity - m_body1.m_angularVelocity));
		}
		public function SetMaxMotorTorque(torque:Number):void{
			m_maxMotorTorque = torque;
		}
		public function GetJointAngle():Number{
			return (((m_body2.m_sweep.a - m_body1.m_sweep.a) - m_referenceAngle));
		}
		public function GetMotorTorque():Number{
			return (m_motorForce);
		}
		override public function InitVelocityConstraints(step:b2TimeStep):void{
			var b1:b2Body;
			var b2:b2Body;
			var tMat:b2Mat22;
			var tX:Number;
			var r1Y:Number;
			var jointAngle:Number;
			b1 = m_body1;
			b2 = m_body2;
			tMat = b1.m_xf.R;
			var r1X:Number = (m_localAnchor1.x - b1.m_sweep.localCenter.x);
			r1Y = (m_localAnchor1.y - b1.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r1X) + (tMat.col2.x * r1Y));
			r1Y = ((tMat.col1.y * r1X) + (tMat.col2.y * r1Y));
			r1X = tX;
			tMat = b2.m_xf.R;
			var r2X:Number = (m_localAnchor2.x - b2.m_sweep.localCenter.x);
			var r2Y:Number = (m_localAnchor2.y - b2.m_sweep.localCenter.y);
			tX = ((tMat.col1.x * r2X) + (tMat.col2.x * r2Y));
			r2Y = ((tMat.col1.y * r2X) + (tMat.col2.y * r2Y));
			r2X = tX;
			var invMass1:Number = b1.m_invMass;
			var invMass2:Number = b2.m_invMass;
			var invI1:Number = b1.m_invI;
			var invI2:Number = b2.m_invI;
			K1.col1.x = (invMass1 + invMass2);
			K1.col2.x = 0;
			K1.col1.y = 0;
			K1.col2.y = (invMass1 + invMass2);
			K2.col1.x = ((invI1 * r1Y) * r1Y);
			K2.col2.x = ((-(invI1) * r1X) * r1Y);
			K2.col1.y = ((-(invI1) * r1X) * r1Y);
			K2.col2.y = ((invI1 * r1X) * r1X);
			K3.col1.x = ((invI2 * r2Y) * r2Y);
			K3.col2.x = ((-(invI2) * r2X) * r2Y);
			K3.col1.y = ((-(invI2) * r2X) * r2Y);
			K3.col2.y = ((invI2 * r2X) * r2X);
			K.SetM(K1);
			K.AddM(K2);
			K.AddM(K3);
			K.Invert(m_pivotMass);
			m_motorMass = (1 / (invI1 + invI2));
			if (m_enableMotor == false){
				m_motorForce = 0;
			};
			if (m_enableLimit){
				jointAngle = ((b2.m_sweep.a - b1.m_sweep.a) - m_referenceAngle);
				if (b2Math.b2Abs((m_upperAngle - m_lowerAngle)) < (2 * b2Settings.b2_angularSlop)){
					m_limitState = e_equalLimits;
				} else {
					if (jointAngle <= m_lowerAngle){
						if (m_limitState != e_atLowerLimit){
							m_limitForce = 0;
						};
						m_limitState = e_atLowerLimit;
					} else {
						if (jointAngle >= m_upperAngle){
							if (m_limitState != e_atUpperLimit){
								m_limitForce = 0;
							};
							m_limitState = e_atUpperLimit;
						} else {
							m_limitState = e_inactiveLimit;
							m_limitForce = 0;
						};
					};
				};
			} else {
				m_limitForce = 0;
			};
			if (step.warmStarting){
				b1.m_linearVelocity.x = (b1.m_linearVelocity.x - ((step.dt * invMass1) * m_pivotForce.x));
				b1.m_linearVelocity.y = (b1.m_linearVelocity.y - ((step.dt * invMass1) * m_pivotForce.y));
				b1.m_angularVelocity = (b1.m_angularVelocity - ((step.dt * invI1) * ((((r1X * m_pivotForce.y) - (r1Y * m_pivotForce.x)) + m_motorForce) + m_limitForce)));
				b2.m_linearVelocity.x = (b2.m_linearVelocity.x + ((step.dt * invMass2) * m_pivotForce.x));
				b2.m_linearVelocity.y = (b2.m_linearVelocity.y + ((step.dt * invMass2) * m_pivotForce.y));
				b2.m_angularVelocity = (b2.m_angularVelocity + ((step.dt * invI2) * ((((r2X * m_pivotForce.y) - (r2Y * m_pivotForce.x)) + m_motorForce) + m_limitForce)));
			} else {
				m_pivotForce.SetZero();
				m_motorForce = 0;
				m_limitForce = 0;
			};
			m_limitPositionImpulse = 0;
		}
		public function EnableLimit(flag:Boolean):void{
			m_enableLimit = flag;
		}
		override public function GetReactionTorque():Number{
			return (m_limitForce);
		}
		public function IsLimitEnabled():Boolean{
			return (m_enableLimit);
		}
		public function IsMotorEnabled():Boolean{
			return (m_enableMotor);
		}
		public function SetLimits(lower:Number, upper:Number):void{
			m_lowerAngle = lower;
			m_upperAngle = upper;
		}

	}
}//package Box2D.Dynamics.Joints 
Section 74
//b2RevoluteJointDef (Box2D.Dynamics.Joints.b2RevoluteJointDef)
package Box2D.Dynamics.Joints {
	import Box2D.Dynamics.*;
	import Box2D.Common.Math.*;

	public class b2RevoluteJointDef extends b2JointDef {

		public var upperAngle:Number;
		public var enableMotor:Boolean;
		public var referenceAngle:Number;
		public var motorSpeed:Number;
		public var localAnchor1:b2Vec2;
		public var localAnchor2:b2Vec2;
		public var enableLimit:Boolean;
		public var lowerAngle:Number;
		public var maxMotorTorque:Number;

		public function b2RevoluteJointDef(){
			localAnchor1 = new b2Vec2();
			localAnchor2 = new b2Vec2();
			super();
			type = b2Joint.e_revoluteJoint;
			localAnchor1.Set(0, 0);
			localAnchor2.Set(0, 0);
			referenceAngle = 0;
			lowerAngle = 0;
			upperAngle = 0;
			maxMotorTorque = 0;
			motorSpeed = 0;
			enableLimit = false;
			enableMotor = false;
		}
		public function Initialize(b1:b2Body, b2:b2Body, anchor:b2Vec2):void{
			body1 = b1;
			body2 = b2;
			localAnchor1 = body1.GetLocalPoint(anchor);
			localAnchor2 = body2.GetLocalPoint(anchor);
			referenceAngle = (body2.GetAngle() - body1.GetAngle());
		}

	}
}//package Box2D.Dynamics.Joints 
Section 75
//b2Body (Box2D.Dynamics.b2Body)
package Box2D.Dynamics {
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;

	public class b2Body {

		public var m_next:b2Body;
		public var m_xf:b2XForm;
		public var m_contactList:b2ContactEdge;
		public var m_angularVelocity:Number;
		public var m_shapeList:b2Shape;
		public var m_force:b2Vec2;
		public var m_mass:Number;
		public var m_sweep:b2Sweep;
		public var m_torque:Number;
		public var m_userData;
		public var m_flags:uint;
		public var m_world:b2World;
		public var m_prev:b2Body;
		public var m_invMass:Number;
		public var m_type:int;
		public var m_linearDamping:Number;
		public var m_shapeCount:int;
		public var m_angularDamping:Number;
		public var m_invI:Number;
		public var m_linearVelocity:b2Vec2;
		public var m_sleepTime:Number;
		public var m_jointList:b2JointEdge;
		public var m_I:Number;

		public static var e_fixedRotationFlag:uint = 64;
		public static var e_frozenFlag:uint = 2;
		public static var e_maxTypes:uint = 3;
		public static var e_sleepFlag:uint = 8;
		private static var s_massData:b2MassData = new b2MassData();
		public static var e_bulletFlag:uint = 32;
		public static var e_staticType:uint = 1;
		public static var e_islandFlag:uint = 4;
		public static var e_allowSleepFlag:uint = 16;
		private static var s_xf1:b2XForm = new b2XForm();
		public static var e_dynamicType:uint = 2;

		public function b2Body(bd:b2BodyDef, world:b2World){
			m_xf = new b2XForm();
			m_sweep = new b2Sweep();
			m_linearVelocity = new b2Vec2();
			m_force = new b2Vec2();
			super();
			m_flags = 0;
			if (bd.isBullet){
				m_flags = (m_flags | e_bulletFlag);
			};
			if (bd.fixedRotation){
				m_flags = (m_flags | e_fixedRotationFlag);
			};
			if (bd.allowSleep){
				m_flags = (m_flags | e_allowSleepFlag);
			};
			if (bd.isSleeping){
				m_flags = (m_flags | e_sleepFlag);
			};
			m_world = world;
			m_xf.position.SetV(bd.position);
			m_xf.R.Set(bd.angle);
			m_sweep.localCenter.SetV(bd.massData.center);
			m_sweep.t0 = 1;
			m_sweep.a0 = (m_sweep.a = bd.angle);
			var tMat:b2Mat22 = m_xf.R;
			var tVec:b2Vec2 = m_sweep.localCenter;
			m_sweep.c.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			m_sweep.c.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			m_sweep.c.x = (m_sweep.c.x + m_xf.position.x);
			m_sweep.c.y = (m_sweep.c.y + m_xf.position.y);
			m_sweep.c0.SetV(m_sweep.c);
			m_jointList = null;
			m_contactList = null;
			m_prev = null;
			m_next = null;
			m_linearDamping = bd.linearDamping;
			m_angularDamping = bd.angularDamping;
			m_force.Set(0, 0);
			m_torque = 0;
			m_linearVelocity.SetZero();
			m_angularVelocity = 0;
			m_sleepTime = 0;
			m_invMass = 0;
			m_I = 0;
			m_invI = 0;
			m_mass = bd.massData.mass;
			if (m_mass > 0){
				m_invMass = (1 / m_mass);
			};
			if ((m_flags & b2Body.e_fixedRotationFlag) == 0){
				m_I = bd.massData.I;
			};
			if (m_I > 0){
				m_invI = (1 / m_I);
			};
			if ((((m_invMass == 0)) && ((m_invI == 0)))){
				m_type = e_staticType;
			} else {
				m_type = e_dynamicType;
			};
			m_userData = bd.userData;
			m_shapeList = null;
			m_shapeCount = 0;
		}
		public function GetLinearVelocityFromWorldPoint(worldPoint:b2Vec2):b2Vec2{
			return (new b2Vec2((m_linearVelocity.x + (m_angularVelocity * (worldPoint.y - m_sweep.c.y))), (m_linearVelocity.x - (m_angularVelocity * (worldPoint.x - m_sweep.c.x)))));
		}
		public function SetLinearVelocity(v:b2Vec2):void{
			m_linearVelocity.SetV(v);
		}
		public function WakeUp():void{
			m_flags = (m_flags & ~(e_sleepFlag));
			m_sleepTime = 0;
		}
		public function GetLocalCenter():b2Vec2{
			return (m_sweep.localCenter);
		}
		public function ApplyTorque(torque:Number):void{
			if (IsSleeping()){
				WakeUp();
			};
			m_torque = (m_torque + torque);
		}
		public function IsFrozen():Boolean{
			return (((m_flags & e_frozenFlag) == e_frozenFlag));
		}
		public function IsDynamic():Boolean{
			return ((m_type == e_dynamicType));
		}
		public function GetLinearVelocity():b2Vec2{
			return (m_linearVelocity);
		}
		public function SynchronizeTransform():void{
			m_xf.R.Set(m_sweep.a);
			var tMat:b2Mat22 = m_xf.R;
			var tVec:b2Vec2 = m_sweep.localCenter;
			m_xf.position.x = (m_sweep.c.x - ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			m_xf.position.y = (m_sweep.c.y - ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
		}
		public function GetInertia():Number{
			return (m_I);
		}
		public function IsSleeping():Boolean{
			return (((m_flags & e_sleepFlag) == e_sleepFlag));
		}
		public function SetMassFromShapes():void{
			var s:b2Shape;
			if (m_world.m_lock == true){
				return;
			};
			m_mass = 0;
			m_invMass = 0;
			m_I = 0;
			m_invI = 0;
			var centerX:Number = 0;
			var centerY:Number = 0;
			var massData:b2MassData = s_massData;
			s = m_shapeList;
			while (s) {
				s.ComputeMass(massData);
				m_mass = (m_mass + massData.mass);
				centerX = (centerX + (massData.mass * massData.center.x));
				centerY = (centerY + (massData.mass * massData.center.y));
				m_I = (m_I + massData.I);
				s = s.m_next;
			};
			if (m_mass > 0){
				m_invMass = (1 / m_mass);
				centerX = (centerX * m_invMass);
				centerY = (centerY * m_invMass);
			};
			if ((((m_I > 0)) && (((m_flags & e_fixedRotationFlag) == 0)))){
				m_I = (m_I - (m_mass * ((centerX * centerX) + (centerY * centerY))));
				m_invI = (1 / m_I);
			} else {
				m_I = 0;
				m_invI = 0;
			};
			m_sweep.localCenter.Set(centerX, centerY);
			var tMat:b2Mat22 = m_xf.R;
			var tVec:b2Vec2 = m_sweep.localCenter;
			m_sweep.c.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			m_sweep.c.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			m_sweep.c.x = (m_sweep.c.x + m_xf.position.x);
			m_sweep.c.y = (m_sweep.c.y + m_xf.position.y);
			m_sweep.c0.SetV(m_sweep.c);
			s = m_shapeList;
			while (s) {
				s.UpdateSweepRadius(m_sweep.localCenter);
				s = s.m_next;
			};
			var oldType:int = m_type;
			if ((((m_invMass == 0)) && ((m_invI == 0)))){
				m_type = e_staticType;
			} else {
				m_type = e_dynamicType;
			};
			if (oldType != m_type){
				s = m_shapeList;
				while (s) {
					s.RefilterProxy(m_world.m_broadPhase, m_xf);
					s = s.m_next;
				};
			};
		}
		public function PutToSleep():void{
			m_flags = (m_flags | e_sleepFlag);
			m_sleepTime = 0;
			m_linearVelocity.SetZero();
			m_angularVelocity = 0;
			m_force.SetZero();
			m_torque = 0;
		}
		public function GetJointList():b2JointEdge{
			return (m_jointList);
		}
		public function SetXForm(position:b2Vec2, angle:Number):Boolean{
			var s:b2Shape;
			var inRange:Boolean;
			if (m_world.m_lock == true){
				return (true);
			};
			if (IsFrozen()){
				return (false);
			};
			m_xf.R.Set(angle);
			m_xf.position.SetV(position);
			var tMat:b2Mat22 = m_xf.R;
			var tVec:b2Vec2 = m_sweep.localCenter;
			m_sweep.c.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			m_sweep.c.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			m_sweep.c.x = (m_sweep.c.x + m_xf.position.x);
			m_sweep.c.y = (m_sweep.c.y + m_xf.position.y);
			m_sweep.c0.SetV(m_sweep.c);
			m_sweep.a0 = (m_sweep.a = angle);
			var freeze:Boolean;
			s = m_shapeList;
			while (s) {
				inRange = s.Synchronize(m_world.m_broadPhase, m_xf, m_xf);
				if (inRange == false){
					freeze = true;
					break;
				};
				s = s.m_next;
			};
			if (freeze == true){
				m_flags = (m_flags | e_frozenFlag);
				m_linearVelocity.SetZero();
				m_angularVelocity = 0;
				s = m_shapeList;
				while (s) {
					s.DestroyProxy(m_world.m_broadPhase);
					s = s.m_next;
				};
				return (false);
			};
			m_world.m_broadPhase.Commit();
			return (true);
		}
		public function GetLocalPoint(worldPoint:b2Vec2):b2Vec2{
			return (b2Math.b2MulXT(m_xf, worldPoint));
		}
		public function ApplyForce(force:b2Vec2, point:b2Vec2):void{
			if (IsSleeping()){
				WakeUp();
			};
			m_force.x = (m_force.x + force.x);
			m_force.y = (m_force.y + force.y);
			m_torque = (m_torque + (((point.x - m_sweep.c.x) * force.y) - ((point.y - m_sweep.c.y) * force.x)));
		}
		public function SynchronizeShapes():Boolean{
			var s:b2Shape;
			var xf1:b2XForm = s_xf1;
			xf1.R.Set(m_sweep.a0);
			var tMat:b2Mat22 = xf1.R;
			var tVec:b2Vec2 = m_sweep.localCenter;
			xf1.position.x = (m_sweep.c0.x - ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
			xf1.position.y = (m_sweep.c0.y - ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
			var inRange:Boolean;
			s = m_shapeList;
			while (s) {
				inRange = s.Synchronize(m_world.m_broadPhase, xf1, m_xf);
				if (inRange == false){
					break;
				};
				s = s.m_next;
			};
			if (inRange == false){
				m_flags = (m_flags | e_frozenFlag);
				m_linearVelocity.SetZero();
				m_angularVelocity = 0;
				s = m_shapeList;
				while (s) {
					s.DestroyProxy(m_world.m_broadPhase);
					s = s.m_next;
				};
				return (false);
			};
			return (true);
		}
		public function GetAngle():Number{
			return (m_sweep.a);
		}
		public function GetXForm():b2XForm{
			return (m_xf);
		}
		public function GetLinearVelocityFromLocalPoint(localPoint:b2Vec2):b2Vec2{
			var A:b2Mat22 = m_xf.R;
			var worldPoint:b2Vec2 = new b2Vec2(((A.col1.x * localPoint.x) + (A.col2.x * localPoint.y)), ((A.col1.y * localPoint.x) + (A.col2.y * localPoint.y)));
			worldPoint.x = (worldPoint.x + m_xf.position.x);
			worldPoint.y = (worldPoint.y + m_xf.position.y);
			return (new b2Vec2((m_linearVelocity.x + (m_angularVelocity * (worldPoint.y - m_sweep.c.y))), (m_linearVelocity.x - (m_angularVelocity * (worldPoint.x - m_sweep.c.x)))));
		}
		public function GetNext():b2Body{
			return (m_next);
		}
		public function GetMass():Number{
			return (m_mass);
		}
		public function ApplyImpulse(impulse:b2Vec2, point:b2Vec2):void{
			if (IsSleeping()){
				WakeUp();
			};
			m_linearVelocity.x = (m_linearVelocity.x + (m_invMass * impulse.x));
			m_linearVelocity.y = (m_linearVelocity.y + (m_invMass * impulse.y));
			m_angularVelocity = (m_angularVelocity + (m_invI * (((point.x - m_sweep.c.x) * impulse.y) - ((point.y - m_sweep.c.y) * impulse.x))));
		}
		public function GetAngularVelocity():Number{
			return (m_angularVelocity);
		}
		public function SetAngularVelocity(omega:Number):void{
			m_angularVelocity = omega;
		}
		public function SetMass(massData:b2MassData):void{
			var s:b2Shape;
			var tVec:b2Vec2;
			if (m_world.m_lock == true){
				return;
			};
			m_invMass = 0;
			m_I = 0;
			m_invI = 0;
			m_mass = massData.mass;
			if (m_mass > 0){
				m_invMass = (1 / m_mass);
			};
			if ((m_flags & b2Body.e_fixedRotationFlag) == 0){
				m_I = massData.I;
			};
			if (m_I > 0){
				m_invI = (1 / m_I);
			};
			m_sweep.localCenter.SetV(massData.center);
			var tMat:b2Mat22 = m_xf.R;
			tVec = m_sweep.localCenter;
			m_sweep.c.x = ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y));
			m_sweep.c.y = ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y));
			m_sweep.c.x = (m_sweep.c.x + m_xf.position.x);
			m_sweep.c.y = (m_sweep.c.y + m_xf.position.y);
			m_sweep.c0.SetV(m_sweep.c);
			s = m_shapeList;
			while (s) {
				s.UpdateSweepRadius(m_sweep.localCenter);
				s = s.m_next;
			};
			var oldType:int = m_type;
			if ((((m_invMass == 0)) && ((m_invI == 0)))){
				m_type = e_staticType;
			} else {
				m_type = e_dynamicType;
			};
			if (oldType != m_type){
				s = m_shapeList;
				while (s) {
					s.RefilterProxy(m_world.m_broadPhase, m_xf);
					s = s.m_next;
				};
			};
		}
		public function IsStatic():Boolean{
			return ((m_type == e_staticType));
		}
		public function GetWorldVector(localVector:b2Vec2):b2Vec2{
			return (b2Math.b2MulMV(m_xf.R, localVector));
		}
		public function GetShapeList():b2Shape{
			return (m_shapeList);
		}
		public function Advance(t:Number):void{
			m_sweep.Advance(t);
			m_sweep.c.SetV(m_sweep.c0);
			m_sweep.a = m_sweep.a0;
			SynchronizeTransform();
		}
		public function SetBullet(flag:Boolean):void{
			if (flag){
				m_flags = (m_flags | e_bulletFlag);
			} else {
				m_flags = (m_flags & ~(e_bulletFlag));
			};
		}
		public function CreateShape(def:b2ShapeDef):b2Shape{
			if (m_world.m_lock == true){
				return (null);
			};
			var s:b2Shape = b2Shape.Create(def, m_world.m_blockAllocator);
			s.m_next = m_shapeList;
			m_shapeList = s;
			m_shapeCount++;
			s.m_body = this;
			s.CreateProxy(m_world.m_broadPhase, m_xf);
			s.UpdateSweepRadius(m_sweep.localCenter);
			return (s);
		}
		public function IsConnected(other:b2Body):Boolean{
			var jn:b2JointEdge = m_jointList;
			while (jn) {
				if (jn.other == other){
					return ((jn.joint.m_collideConnected == false));
				};
				jn = jn.next;
			};
			return (false);
		}
		public function DestroyShape(s:b2Shape):void{
			if (m_world.m_lock == true){
				return;
			};
			s.DestroyProxy(m_world.m_broadPhase);
			var node:b2Shape = m_shapeList;
			var found:Boolean;
			while (node != null) {
				if (node == s){
					node = s.m_next;
					found = true;
					break;
				};
				node = node.m_next;
			};
			s.m_body = null;
			s.m_next = null;
			m_shapeCount--;
			b2Shape.Destroy(s, m_world.m_blockAllocator);
		}
		public function GetUserData(){
			return (m_userData);
		}
		public function IsBullet():Boolean{
			return (((m_flags & e_bulletFlag) == e_bulletFlag));
		}
		public function GetWorldCenter():b2Vec2{
			return (m_sweep.c);
		}
		public function AllowSleeping(flag:Boolean):void{
			if (flag){
				m_flags = (m_flags | e_allowSleepFlag);
			} else {
				m_flags = (m_flags & ~(e_allowSleepFlag));
				WakeUp();
			};
		}
		public function SetUserData(data):void{
			m_userData = data;
		}
		public function GetLocalVector(worldVector:b2Vec2):b2Vec2{
			return (b2Math.b2MulTMV(m_xf.R, worldVector));
		}
		public function GetWorldPoint(localPoint:b2Vec2):b2Vec2{
			var A:b2Mat22 = m_xf.R;
			var u:b2Vec2 = new b2Vec2(((A.col1.x * localPoint.x) + (A.col2.x * localPoint.y)), ((A.col1.y * localPoint.x) + (A.col2.y * localPoint.y)));
			u.x = (u.x + m_xf.position.x);
			u.y = (u.y + m_xf.position.y);
			return (u);
		}
		public function GetWorld():b2World{
			return (m_world);
		}
		public function GetPosition():b2Vec2{
			return (m_xf.position);
		}

	}
}//package Box2D.Dynamics 
Section 76
//b2BodyDef (Box2D.Dynamics.b2BodyDef)
package Box2D.Dynamics {
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2BodyDef {

		public var angularDamping:Number;
		public var angle:Number;
		public var isSleeping:Boolean;
		public var position:b2Vec2;
		public var isBullet:Boolean;
		public var allowSleep:Boolean;
		public var userData;
		public var fixedRotation:Boolean;
		public var linearDamping:Number;
		public var massData:b2MassData;

		public function b2BodyDef(){
			massData = new b2MassData();
			position = new b2Vec2();
			super();
			massData.center.SetZero();
			massData.mass = 0;
			massData.I = 0;
			userData = null;
			position.Set(0, 0);
			angle = 0;
			linearDamping = 0;
			angularDamping = 0;
			allowSleep = true;
			isSleeping = false;
			fixedRotation = false;
			isBullet = false;
		}
	}
}//package Box2D.Dynamics 
Section 77
//b2BoundaryListener (Box2D.Dynamics.b2BoundaryListener)
package Box2D.Dynamics {

	public class b2BoundaryListener {

		public function b2BoundaryListener(){
			super();
		}
		public function Violation(body:b2Body):void{
		}

	}
}//package Box2D.Dynamics 
Section 78
//b2ContactFilter (Box2D.Dynamics.b2ContactFilter)
package Box2D.Dynamics {
	import Box2D.Collision.Shapes.*;

	public class b2ContactFilter {

		public static var b2_defaultFilter:b2ContactFilter = new (b2ContactFilter);
;

		public function b2ContactFilter(){
			super();
		}
		public function ShouldCollide(shape1:b2Shape, shape2:b2Shape):Boolean{
			var filter1:b2FilterData = shape1.GetFilterData();
			var filter2:b2FilterData = shape2.GetFilterData();
			if ((((filter1.groupIndex == filter2.groupIndex)) && (!((filter1.groupIndex == 0))))){
				return ((filter1.groupIndex > 0));
			};
			var collide:Boolean = ((!(((filter1.maskBits & filter2.categoryBits) == 0))) && (!(((filter1.categoryBits & filter2.maskBits) == 0))));
			return (collide);
		}

	}
}//package Box2D.Dynamics 
Section 79
//b2ContactListener (Box2D.Dynamics.b2ContactListener)
package Box2D.Dynamics {
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;

	public class b2ContactListener {

		public function b2ContactListener(){
			super();
		}
		public function Add(point:b2ContactPoint):void{
		}
		public function Remove(point:b2ContactPoint):void{
		}
		public function Persist(point:b2ContactPoint):void{
		}
		public function Result(point:b2ContactResult):void{
		}

	}
}//package Box2D.Dynamics 
Section 80
//b2ContactManager (Box2D.Dynamics.b2ContactManager)
package Box2D.Dynamics {
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;

	public class b2ContactManager extends b2PairCallback {

		public var m_world:b2World;
		public var m_destroyImmediate:Boolean;
		public var m_nullContact:b2NullContact;

		private static const s_evalCP:b2ContactPoint = new b2ContactPoint();

		public function b2ContactManager(){
			m_nullContact = new b2NullContact();
			super();
			m_world = null;
			m_destroyImmediate = false;
		}
		override public function PairRemoved(proxyUserData1, proxyUserData2, pairUserData):void{
			if (pairUserData == null){
				return;
			};
			var c:b2Contact = (pairUserData as b2Contact);
			if (c == m_nullContact){
				return;
			};
			Destroy(c);
		}
		public function Destroy(c:b2Contact):void{
			var b1:b2Body;
			var b2:b2Body;
			var manifolds:Array;
			var cp:b2ContactPoint;
			var i:int;
			var manifold:b2Manifold;
			var j:int;
			var mp:b2ManifoldPoint;
			var v1:b2Vec2;
			var v2:b2Vec2;
			var shape1:b2Shape = c.m_shape1;
			var shape2:b2Shape = c.m_shape2;
			var manifoldCount:int = c.m_manifoldCount;
			if ((((manifoldCount > 0)) && (m_world.m_contactListener))){
				b1 = shape1.m_body;
				b2 = shape2.m_body;
				manifolds = c.GetManifolds();
				cp = s_evalCP;
				cp.shape1 = c.m_shape1;
				cp.shape2 = c.m_shape2;
				cp.friction = c.m_friction;
				cp.restitution = c.m_restitution;
				i = 0;
				while (i < manifoldCount) {
					manifold = manifolds[i];
					cp.normal.SetV(manifold.normal);
					j = 0;
					while (j < manifold.pointCount) {
						mp = manifold.points[j];
						cp.position = b1.GetWorldPoint(mp.localPoint1);
						v1 = b1.GetLinearVelocityFromLocalPoint(mp.localPoint1);
						v2 = b2.GetLinearVelocityFromLocalPoint(mp.localPoint2);
						cp.velocity.Set((v2.x - v1.x), (v2.y - v1.y));
						cp.separation = mp.separation;
						cp.id.key = mp.id._key;
						m_world.m_contactListener.Remove(cp);
						j++;
					};
					i++;
				};
			};
			if (c.m_prev){
				c.m_prev.m_next = c.m_next;
			};
			if (c.m_next){
				c.m_next.m_prev = c.m_prev;
			};
			if (c == m_world.m_contactList){
				m_world.m_contactList = c.m_next;
			};
			var body1:b2Body = shape1.m_body;
			var body2:b2Body = shape2.m_body;
			if (c.m_node1.prev){
				c.m_node1.prev.next = c.m_node1.next;
			};
			if (c.m_node1.next){
				c.m_node1.next.prev = c.m_node1.prev;
			};
			if (c.m_node1 == body1.m_contactList){
				body1.m_contactList = c.m_node1.next;
			};
			if (c.m_node2.prev){
				c.m_node2.prev.next = c.m_node2.next;
			};
			if (c.m_node2.next){
				c.m_node2.next.prev = c.m_node2.prev;
			};
			if (c.m_node2 == body2.m_contactList){
				body2.m_contactList = c.m_node2.next;
			};
			b2Contact.Destroy(c, m_world.m_blockAllocator);
			m_world.m_contactCount--;
		}
		override public function PairAdded(proxyUserData1, proxyUserData2){
			var shape1:b2Shape = (proxyUserData1 as b2Shape);
			var shape2:b2Shape = (proxyUserData2 as b2Shape);
			var body1:b2Body = shape1.m_body;
			var body2:b2Body = shape2.m_body;
			if (((body1.IsStatic()) && (body2.IsStatic()))){
				return (m_nullContact);
			};
			if (shape1.m_body == shape2.m_body){
				return (m_nullContact);
			};
			if (body2.IsConnected(body1)){
				return (m_nullContact);
			};
			if (((!((m_world.m_contactFilter == null))) && ((m_world.m_contactFilter.ShouldCollide(shape1, shape2) == false)))){
				return (m_nullContact);
			};
			var c:b2Contact = b2Contact.Create(shape1, shape2, m_world.m_blockAllocator);
			if (c == null){
				return (m_nullContact);
			};
			shape1 = c.m_shape1;
			shape2 = c.m_shape2;
			body1 = shape1.m_body;
			body2 = shape2.m_body;
			c.m_prev = null;
			c.m_next = m_world.m_contactList;
			if (m_world.m_contactList != null){
				m_world.m_contactList.m_prev = c;
			};
			m_world.m_contactList = c;
			c.m_node1.contact = c;
			c.m_node1.other = body2;
			c.m_node1.prev = null;
			c.m_node1.next = body1.m_contactList;
			if (body1.m_contactList != null){
				body1.m_contactList.prev = c.m_node1;
			};
			body1.m_contactList = c.m_node1;
			c.m_node2.contact = c;
			c.m_node2.other = body1;
			c.m_node2.prev = null;
			c.m_node2.next = body2.m_contactList;
			if (body2.m_contactList != null){
				body2.m_contactList.prev = c.m_node2;
			};
			body2.m_contactList = c.m_node2;
			m_world.m_contactCount++;
			return (c);
		}
		public function Collide():void{
			var body1:b2Body;
			var body2:b2Body;
			var c:b2Contact = m_world.m_contactList;
			while (c) {
				body1 = c.m_shape1.m_body;
				body2 = c.m_shape2.m_body;
				if (((body1.IsSleeping()) && (body2.IsSleeping()))){
				} else {
					c.Update(m_world.m_contactListener);
				};
				c = c.m_next;
			};
		}

	}
}//package Box2D.Dynamics 
Section 81
//b2DebugDraw (Box2D.Dynamics.b2DebugDraw)
package Box2D.Dynamics {
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class b2DebugDraw {

		public var m_xformScale:Number;// = 1
		public var m_fillAlpha:Number;// = 1
		public var m_alpha:Number;// = 1
		public var m_lineThickness:Number;// = 1
		public var m_drawFlags:uint;
		public var m_drawScale:Number;// = 1
		public var m_sprite:Sprite;

		public static var e_coreShapeBit:uint = 4;
		public static var e_shapeBit:uint = 1;
		public static var e_centerOfMassBit:uint = 64;
		public static var e_aabbBit:uint = 8;
		public static var e_obbBit:uint = 16;
		public static var e_pairBit:uint = 32;
		public static var e_jointBit:uint = 2;

		public function b2DebugDraw(){
			super();
			m_drawFlags = 0;
		}
		public function DrawPolyline(vertices:Array, vertexCount:int, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			var i = 1;
			while (i < vertexCount) {
				m_sprite.graphics.lineTo((vertices[i].x * m_drawScale), (vertices[i].y * m_drawScale));
				i++;
			};
		}
		public function DrawConcaveArc(vertices:Array, vertexCount:int, center:b2Vec2, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			var s_numSegs:Number = 16;
			var dx:Number = (vertices[0].x - center.x);
			var dy:Number = (vertices[0].y - center.y);
			var theta1:Number = Math.atan2(dy, dx);
			var theta2:Number = Math.atan2((vertices[1].y - center.y), (vertices[1].x - center.x));
			var r:Number = Math.sqrt(((dx * dx) + (dy * dy)));
			while (theta2 > theta1) {
				theta2 = (theta2 - (Math.PI * 2));
			};
			var dtheta:Number = ((theta1 - theta2) / s_numSegs);
			var theta:Number = theta1;
			while (theta > theta2) {
				m_sprite.graphics.lineTo(((center.x + (r * Math.cos(theta))) * m_drawScale), ((center.y + (r * Math.sin(theta))) * m_drawScale));
				theta = (theta - dtheta);
			};
			var i = 1;
			while (i < vertexCount) {
				m_sprite.graphics.lineTo((vertices[i].x * m_drawScale), (vertices[i].y * m_drawScale));
				i++;
			};
			m_sprite.graphics.lineTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
		}
		public function DrawSolidConcaveArc(vertices:Array, vertexCount:int, center:b2Vec2, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			m_sprite.graphics.beginFill(color.color, m_fillAlpha);
			var s_numSegs:Number = 16;
			var dx:Number = (vertices[0].x - center.x);
			var dy:Number = (vertices[0].y - center.y);
			var theta1:Number = Math.atan2(dy, dx);
			var theta2:Number = Math.atan2((vertices[1].y - center.y), (vertices[1].x - center.x));
			var r:Number = Math.sqrt(((dx * dx) + (dy * dy)));
			while (theta2 > theta1) {
				theta2 = (theta2 - (Math.PI * 2));
			};
			var dtheta:Number = ((theta1 - theta2) / s_numSegs);
			var theta:Number = theta1;
			while (theta > theta2) {
				m_sprite.graphics.lineTo(((center.x + (r * Math.cos(theta))) * m_drawScale), ((center.y + (r * Math.sin(theta))) * m_drawScale));
				theta = (theta - dtheta);
			};
			var i = 1;
			while (i < vertexCount) {
				m_sprite.graphics.lineTo((vertices[i].x * m_drawScale), (vertices[i].y * m_drawScale));
				i++;
			};
			m_sprite.graphics.lineTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			m_sprite.graphics.endFill();
		}
		public function DrawSolidPolygon(vertices:Array, vertexCount:int, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			m_sprite.graphics.beginFill(color.color, m_fillAlpha);
			var i = 1;
			while (i < vertexCount) {
				m_sprite.graphics.lineTo((vertices[i].x * m_drawScale), (vertices[i].y * m_drawScale));
				i++;
			};
			m_sprite.graphics.lineTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			m_sprite.graphics.endFill();
		}
		public function DrawCircle(center:b2Vec2, radius:Number, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.drawCircle((center.x * m_drawScale), (center.y * m_drawScale), (radius * m_drawScale));
		}
		public function DrawSolidCircle(center:b2Vec2, radius:Number, axis:b2Vec2, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo(0, 0);
			m_sprite.graphics.beginFill(color.color, m_fillAlpha);
			m_sprite.graphics.drawCircle((center.x * m_drawScale), (center.y * m_drawScale), (radius * m_drawScale));
			m_sprite.graphics.endFill();
			m_sprite.graphics.moveTo((center.x * m_drawScale), (center.y * m_drawScale));
			m_sprite.graphics.lineTo(((center.x + (axis.x * radius)) * m_drawScale), ((center.y + (axis.y * radius)) * m_drawScale));
		}
		public function DrawXForm(xf:b2XForm):void{
			m_sprite.graphics.lineStyle(m_lineThickness, 0xFF0000, m_alpha);
			m_sprite.graphics.moveTo((xf.position.x * m_drawScale), (xf.position.y * m_drawScale));
			m_sprite.graphics.lineTo(((xf.position.x + (m_xformScale * xf.R.col1.x)) * m_drawScale), ((xf.position.y + (m_xformScale * xf.R.col1.y)) * m_drawScale));
			m_sprite.graphics.lineStyle(m_lineThickness, 0xFF00, m_alpha);
			m_sprite.graphics.moveTo((xf.position.x * m_drawScale), (xf.position.y * m_drawScale));
			m_sprite.graphics.lineTo(((xf.position.x + (m_xformScale * xf.R.col2.x)) * m_drawScale), ((xf.position.y + (m_xformScale * xf.R.col2.y)) * m_drawScale));
		}
		public function ClearFlags(flags:uint):void{
			m_drawFlags = (m_drawFlags & ~(flags));
		}
		public function SetFlags(flags:uint):void{
			m_drawFlags = flags;
		}
		public function DrawCurve(p1:b2Vec2, p2:b2Vec2, center:b2Vec2, color:b2Color):void{
			var s_numSegs:Number = 16;
			var dx:Number = (p1.x - center.x);
			var dy:Number = (p1.y - center.y);
			var theta1:Number = Math.atan2(dy, dx);
			var theta2:Number = Math.atan2((p2.y - center.y), (p2.x - center.x));
			var r:Number = Math.sqrt(((dx * dx) + (dy * dy)));
			while (theta2 < theta1) {
				theta2 = (theta2 + (Math.PI * 2));
			};
			var dtheta:Number = ((theta2 - theta1) / s_numSegs);
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((p1.x * m_drawScale), (p1.y * m_drawScale));
			var theta:Number = theta1;
			while (theta <= theta2) {
				m_sprite.graphics.lineTo(((center.x + (r * Math.cos(theta))) * m_drawScale), ((center.y + (r * Math.sin(theta))) * m_drawScale));
				theta = (theta + dtheta);
			};
		}
		public function AppendFlags(flags:uint):void{
			m_drawFlags = (m_drawFlags | flags);
		}
		public function DrawSegment(p1:b2Vec2, p2:b2Vec2, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((p1.x * m_drawScale), (p1.y * m_drawScale));
			m_sprite.graphics.lineTo((p2.x * m_drawScale), (p2.y * m_drawScale));
		}
		public function GetFlags():uint{
			return (m_drawFlags);
		}
		public function DrawPolygon(vertices:Array, vertexCount:int, color:b2Color):void{
			m_sprite.graphics.lineStyle(m_lineThickness, color.color, m_alpha);
			m_sprite.graphics.moveTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
			var i = 1;
			while (i < vertexCount) {
				m_sprite.graphics.lineTo((vertices[i].x * m_drawScale), (vertices[i].y * m_drawScale));
				i++;
			};
			m_sprite.graphics.lineTo((vertices[0].x * m_drawScale), (vertices[0].y * m_drawScale));
		}

	}
}//package Box2D.Dynamics 
Section 82
//b2DestructionListener (Box2D.Dynamics.b2DestructionListener)
package Box2D.Dynamics {
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;

	public class b2DestructionListener {

		public function b2DestructionListener(){
			super();
		}
		public function SayGoodbyeShape(shape:b2Shape):void{
		}
		public function SayGoodbyeJoint(joint:b2Joint):void{
		}

	}
}//package Box2D.Dynamics 
Section 83
//b2Island (Box2D.Dynamics.b2Island)
package Box2D.Dynamics {
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Common.*;

	public class b2Island {

		public var m_listener:b2ContactListener;
		public var m_positionIterationCount:int;
		public var m_bodyCapacity:int;
		public var m_bodies:Array;
		public var m_joints:Array;
		public var m_jointCapacity:int;
		public var m_contactCount:int;
		public var m_contacts:Array;
		public var m_contactCapacity:int;
		public var m_jointCount:int;
		public var m_allocator;
		public var m_bodyCount:int;

		private static var s_reportCR:b2ContactResult = new b2ContactResult();

		public function b2Island(bodyCapacity:int, contactCapacity:int, jointCapacity:int, allocator, listener:b2ContactListener){
			var i:int;
			super();
			m_bodyCapacity = bodyCapacity;
			m_contactCapacity = contactCapacity;
			m_jointCapacity = jointCapacity;
			m_bodyCount = 0;
			m_contactCount = 0;
			m_jointCount = 0;
			m_allocator = allocator;
			m_listener = listener;
			m_bodies = new Array(bodyCapacity);
			i = 0;
			while (i < bodyCapacity) {
				m_bodies[i] = null;
				i++;
			};
			m_contacts = new Array(contactCapacity);
			i = 0;
			while (i < contactCapacity) {
				m_contacts[i] = null;
				i++;
			};
			m_joints = new Array(jointCapacity);
			i = 0;
			while (i < jointCapacity) {
				m_joints[i] = null;
				i++;
			};
			m_positionIterationCount = 0;
		}
		public function AddBody(body:b2Body):void{
			var _local2 = m_bodyCount++;
			m_bodies[_local2] = body;
		}
		public function AddJoint(joint:b2Joint):void{
			var _local2 = m_jointCount++;
			m_joints[_local2] = joint;
		}
		public function Report(constraints:Array):void{
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var c:b2Contact;
			var cc:b2ContactConstraint;
			var cr:b2ContactResult;
			var b1:b2Body;
			var manifoldCount:int;
			var manifolds:Array;
			var j:int;
			var manifold:b2Manifold;
			var k:int;
			var point:b2ManifoldPoint;
			var ccp:b2ContactConstraintPoint;
			if (m_listener == null){
				return;
			};
			var i:int;
			while (i < m_contactCount) {
				c = m_contacts[i];
				cc = constraints[i];
				cr = s_reportCR;
				cr.shape1 = c.m_shape1;
				cr.shape2 = c.m_shape2;
				b1 = cr.shape1.m_body;
				manifoldCount = c.m_manifoldCount;
				manifolds = c.GetManifolds();
				j = 0;
				while (j < manifoldCount) {
					manifold = manifolds[j];
					cr.normal.SetV(manifold.normal);
					k = 0;
					while (k < manifold.pointCount) {
						point = manifold.points[k];
						ccp = cc.points[k];
						cr.position = b1.GetWorldPoint(point.localPoint1);
						cr.normalImpulse = ccp.normalImpulse;
						cr.tangentImpulse = ccp.tangentImpulse;
						cr.id.key = point.id.key;
						m_listener.Result(cr);
						k++;
					};
					j++;
				};
				i++;
			};
		}
		public function AddContact(contact:b2Contact):void{
			var _local2 = m_contactCount++;
			m_contacts[_local2] = contact;
		}
		public function Solve(step:b2TimeStep, gravity:b2Vec2, correctPositions:Boolean, allowSleep:Boolean):void{
			var i:int;
			var b:b2Body;
			var joint:b2Joint;
			var j:int;
			var contactsOkay:Boolean;
			var jointsOkay:Boolean;
			var jointOkay:Boolean;
			var minSleepTime:Number;
			var linTolSqr:Number;
			var angTolSqr:Number;
			i = 0;
			while (i < m_bodyCount) {
				b = m_bodies[i];
				if (b.IsStatic()){
				} else {
					b.m_linearVelocity.x = (b.m_linearVelocity.x + (step.dt * (gravity.x + (b.m_invMass * b.m_force.x))));
					b.m_linearVelocity.y = (b.m_linearVelocity.y + (step.dt * (gravity.y + (b.m_invMass * b.m_force.y))));
					b.m_angularVelocity = (b.m_angularVelocity + ((step.dt * b.m_invI) * b.m_torque));
					b.m_force.SetZero();
					b.m_torque = 0;
					b.m_linearVelocity.Multiply(b2Math.b2Clamp((1 - (step.dt * b.m_linearDamping)), 0, 1));
					b.m_angularVelocity = (b.m_angularVelocity * b2Math.b2Clamp((1 - (step.dt * b.m_angularDamping)), 0, 1));
					if (b.m_linearVelocity.LengthSquared() > b2Settings.b2_maxLinearVelocitySquared){
						b.m_linearVelocity.Normalize();
						b.m_linearVelocity.x = (b.m_linearVelocity.x * b2Settings.b2_maxLinearVelocity);
						b.m_linearVelocity.y = (b.m_linearVelocity.y * b2Settings.b2_maxLinearVelocity);
					};
					if ((b.m_angularVelocity * b.m_angularVelocity) > b2Settings.b2_maxAngularVelocitySquared){
						if (b.m_angularVelocity < 0){
							b.m_angularVelocity = -(b2Settings.b2_maxAngularVelocity);
						} else {
							b.m_angularVelocity = b2Settings.b2_maxAngularVelocity;
						};
					};
				};
				i++;
			};
			var contactSolver:b2ContactSolver = new b2ContactSolver(step, m_contacts, m_contactCount, m_allocator);
			contactSolver.InitVelocityConstraints(step);
			i = 0;
			while (i < m_jointCount) {
				joint = m_joints[i];
				joint.InitVelocityConstraints(step);
				i++;
			};
			i = 0;
			while (i < step.maxIterations) {
				contactSolver.SolveVelocityConstraints();
				j = 0;
				while (j < m_jointCount) {
					joint = m_joints[j];
					joint.SolveVelocityConstraints(step);
					j++;
				};
				i++;
			};
			contactSolver.FinalizeVelocityConstraints();
			i = 0;
			while (i < m_bodyCount) {
				b = m_bodies[i];
				if (b.IsStatic()){
				} else {
					b.m_sweep.c0.SetV(b.m_sweep.c);
					b.m_sweep.a0 = b.m_sweep.a;
					b.m_sweep.c.x = (b.m_sweep.c.x + (step.dt * b.m_linearVelocity.x));
					b.m_sweep.c.y = (b.m_sweep.c.y + (step.dt * b.m_linearVelocity.y));
					b.m_sweep.a = (b.m_sweep.a + (step.dt * b.m_angularVelocity));
					b.SynchronizeTransform();
				};
				i++;
			};
			if (correctPositions){
				i = 0;
				while (i < m_jointCount) {
					joint = m_joints[i];
					joint.InitPositionConstraints();
					i++;
				};
				m_positionIterationCount = 0;
				while (m_positionIterationCount < step.maxIterations) {
					contactsOkay = contactSolver.SolvePositionConstraints(b2Settings.b2_contactBaumgarte);
					jointsOkay = true;
					i = 0;
					while (i < m_jointCount) {
						joint = m_joints[i];
						jointOkay = joint.SolvePositionConstraints();
						jointsOkay = ((jointsOkay) && (jointOkay));
						i++;
					};
					if (((contactsOkay) && (jointsOkay))){
						break;
					};
					m_positionIterationCount++;
				};
			};
			Report(contactSolver.m_constraints);
			if (allowSleep){
				minSleepTime = Number.MAX_VALUE;
				linTolSqr = (b2Settings.b2_linearSleepTolerance * b2Settings.b2_linearSleepTolerance);
				angTolSqr = (b2Settings.b2_angularSleepTolerance * b2Settings.b2_angularSleepTolerance);
				i = 0;
				while (i < m_bodyCount) {
					b = m_bodies[i];
					if (b.m_invMass == 0){
					} else {
						if ((b.m_flags & b2Body.e_allowSleepFlag) == 0){
							b.m_sleepTime = 0;
							minSleepTime = 0;
						};
						if (((((((b.m_flags & b2Body.e_allowSleepFlag) == 0)) || (((b.m_angularVelocity * b.m_angularVelocity) > angTolSqr)))) || ((b2Math.b2Dot(b.m_linearVelocity, b.m_linearVelocity) > linTolSqr)))){
							b.m_sleepTime = 0;
							minSleepTime = 0;
						} else {
							b.m_sleepTime = (b.m_sleepTime + step.dt);
							minSleepTime = b2Math.b2Min(minSleepTime, b.m_sleepTime);
						};
					};
					i++;
				};
				if (minSleepTime >= b2Settings.b2_timeToSleep){
					i = 0;
					while (i < m_bodyCount) {
						b = m_bodies[i];
						b.m_flags = (b.m_flags | b2Body.e_sleepFlag);
						b.m_linearVelocity.SetZero();
						b.m_angularVelocity = 0;
						i++;
					};
				};
			};
		}
		public function Clear():void{
			m_bodyCount = 0;
			m_contactCount = 0;
			m_jointCount = 0;
		}
		public function SolveTOI(subStep:b2TimeStep):void{
			var i:int;
			var b:b2Body;
			var contactsOkay:Boolean;
			var contactSolver:b2ContactSolver = new b2ContactSolver(subStep, m_contacts, m_contactCount, m_allocator);
			i = 0;
			while (i < subStep.maxIterations) {
				contactSolver.SolveVelocityConstraints();
				i++;
			};
			i = 0;
			while (i < m_bodyCount) {
				b = m_bodies[i];
				if (b.IsStatic()){
				} else {
					b.m_sweep.c0.SetV(b.m_sweep.c);
					b.m_sweep.a0 = b.m_sweep.a;
					b.m_sweep.c.x = (b.m_sweep.c.x + (subStep.dt * b.m_linearVelocity.x));
					b.m_sweep.c.y = (b.m_sweep.c.y + (subStep.dt * b.m_linearVelocity.y));
					b.m_sweep.a = (b.m_sweep.a + (subStep.dt * b.m_angularVelocity));
					b.SynchronizeTransform();
				};
				i++;
			};
			var k_toiBaumgarte:Number = 0.75;
			i = 0;
			while (i < subStep.maxIterations) {
				contactsOkay = contactSolver.SolvePositionConstraints(k_toiBaumgarte);
				if (contactsOkay){
					break;
				};
				i++;
			};
			Report(contactSolver.m_constraints);
		}

	}
}//package Box2D.Dynamics 
Section 84
//b2TimeStep (Box2D.Dynamics.b2TimeStep)
package Box2D.Dynamics {

	public class b2TimeStep {

		public var warmStarting:Boolean;
		public var positionCorrection:Boolean;
		public var dt:Number;
		public var maxIterations:int;
		public var dtRatio:Number;
		public var inv_dt:Number;

		public function b2TimeStep(){
			super();
		}
	}
}//package Box2D.Dynamics 
Section 85
//b2World (Box2D.Dynamics.b2World)
package Box2D.Dynamics {
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import zahid.games.common.*;

	public class b2World {

		public var m_inv_dt0:Number;
		public var m_boundaryListener:b2BoundaryListener;
		public var m_contactList:b2Contact;
		public var m_blockAllocator;
		public var m_contactListener:b2ContactListener;
		public var m_allowSleep:Boolean;
		public var m_broadPhase:b2BroadPhase;
		public var m_destructionListener:b2DestructionListener;
		public var m_jointCount:int;
		public var m_bodyCount:int;
		public var m_lock:Boolean;
		public var m_positionIterationCount:int;
		public var m_groundBody:b2Body;
		public var m_contactCount:int;
		public var m_debugDraw:b2DebugDraw;
		public var m_contactFilter:b2ContactFilter;
		public var m_bodyList:b2Body;
		public var m_stackAllocator;
		public var m_jointList:b2Joint;
		public var m_gravity:b2Vec2;
		public var m_contactManager:b2ContactManager;

		private static var s_jointColor:b2Color = new b2Color(0.5, 0.8, 0.8);
		public static var m_continuousPhysics:Boolean;
		public static var m_warmStarting:Boolean;
		private static var s_coreColor:b2Color = new b2Color(0.9, 0.6, 0.6);
		public static var m_positionCorrection:Boolean;
		private static var s_xf:b2XForm = new b2XForm();

		public function b2World(worldAABB:b2AABB, gravity:b2Vec2, doSleep:Boolean){
			m_contactManager = new b2ContactManager();
			super();
			m_destructionListener = null;
			m_boundaryListener = null;
			m_contactFilter = b2ContactFilter.b2_defaultFilter;
			m_contactListener = null;
			m_debugDraw = null;
			m_bodyList = null;
			m_contactList = null;
			m_jointList = null;
			m_bodyCount = 0;
			m_contactCount = 0;
			m_jointCount = 0;
			m_positionCorrection = true;
			m_warmStarting = true;
			m_continuousPhysics = true;
			m_allowSleep = doSleep;
			m_gravity = gravity;
			m_lock = false;
			m_inv_dt0 = 0;
			m_contactManager.m_world = this;
			m_broadPhase = new b2BroadPhase(worldAABB, m_contactManager);
			var bd:b2BodyDef = new b2BodyDef();
			m_groundBody = CreateBody(bd);
			b2Distance.InitializeRegisters();
			var userdata:* = new b2zUserData("ground", "ground");
			m_groundBody.SetUserData(userdata);
		}
		public function DrawJoint(joint:b2Joint):void{
			var pulley:b2PulleyJoint;
			var s1:b2Vec2;
			var s2:b2Vec2;
			var b1:b2Body = joint.m_body1;
			var b2:b2Body = joint.m_body2;
			var xf1:b2XForm = b1.m_xf;
			var xf2:b2XForm = b2.m_xf;
			var x1:b2Vec2 = xf1.position;
			var x2:b2Vec2 = xf2.position;
			var p1:b2Vec2 = joint.GetAnchor1();
			var p2:b2Vec2 = joint.GetAnchor2();
			var color:b2Color = s_jointColor;
			switch (joint.m_type){
				case b2Joint.e_distanceJoint:
					m_debugDraw.DrawSegment(p1, p2, color);
					break;
				case b2Joint.e_pulleyJoint:
					pulley = (joint as b2PulleyJoint);
					s1 = pulley.GetGroundAnchor1();
					s2 = pulley.GetGroundAnchor2();
					m_debugDraw.DrawSegment(s1, p1, color);
					m_debugDraw.DrawSegment(s2, p2, color);
					m_debugDraw.DrawSegment(s1, s2, color);
					break;
				case b2Joint.e_mouseJoint:
					m_debugDraw.DrawSegment(p1, p2, color);
					break;
				default:
					if (b1 != m_groundBody){
						m_debugDraw.DrawSegment(x1, p1, color);
					};
					m_debugDraw.DrawSegment(p1, p2, color);
					if (b2 != m_groundBody){
						m_debugDraw.DrawSegment(x2, p2, color);
					};
			};
		}
		public function Refilter(shape:b2Shape):void{
			shape.RefilterProxy(m_broadPhase, shape.m_body.m_xf);
		}
		public function SetDebugDraw(debugDraw:b2DebugDraw):void{
			m_debugDraw = debugDraw;
		}
		public function SetContactFilter(filter:b2ContactFilter):void{
			m_contactFilter = filter;
		}
		public function GetProxyCount():int{
			return (m_broadPhase.m_proxyCount);
		}
		public function DrawDebugData():void{
			var i:int;
			var b:b2Body;
			var s:b2Shape;
			var j:b2Joint;
			var bp:b2BroadPhase;
			var xf:b2XForm;
			var core:Boolean;
			var index:uint;
			var pair:b2Pair;
			var p1:b2Proxy;
			var p2:b2Proxy;
			var worldLower:b2Vec2;
			var worldUpper:b2Vec2;
			var p:b2Proxy;
			var poly:b2PolygonShape;
			var obb:b2OBB;
			var h:b2Vec2;
			var tMat:b2Mat22;
			var tVec:b2Vec2;
			var tX:Number;
			if (m_debugDraw == null){
				return;
			};
			m_debugDraw.m_sprite.graphics.clear();
			var flags:uint = m_debugDraw.GetFlags();
			var invQ:b2Vec2 = new b2Vec2();
			var x1:b2Vec2 = new b2Vec2();
			var x2:b2Vec2 = new b2Vec2();
			var color:b2Color = new b2Color(0, 0, 0);
			var b1:b2AABB = new b2AABB();
			var b2:b2AABB = new b2AABB();
			var vs:Array = [new b2Vec2(), new b2Vec2(), new b2Vec2(), new b2Vec2()];
			if ((flags & b2DebugDraw.e_shapeBit)){
				core = ((flags & b2DebugDraw.e_coreShapeBit) == b2DebugDraw.e_coreShapeBit);
				b = m_bodyList;
				while (b) {
					xf = b.m_xf;
					s = b.GetShapeList();
					while (s) {
						if (b.IsStatic()){
							DrawShape(s, xf, new b2Color(0.5, 0.9, 0.5), core);
						} else {
							if (b.IsSleeping()){
								DrawShape(s, xf, new b2Color(0.5, 0.5, 0.9), core);
							} else {
								DrawShape(s, xf, new b2Color(0.9, 0.9, 0.9), core);
							};
						};
						s = s.m_next;
					};
					b = b.m_next;
				};
			};
			if ((flags & b2DebugDraw.e_jointBit)){
				j = m_jointList;
				while (j) {
					DrawJoint(j);
					j = j.m_next;
				};
			};
			if ((flags & b2DebugDraw.e_pairBit)){
				bp = m_broadPhase;
				invQ.Set((1 / bp.m_quantizationFactor.x), (1 / bp.m_quantizationFactor.y));
				color.Set(0.9, 0.9, 0.3);
				i = 0;
				while (i < b2Pair.b2_tableCapacity) {
					index = bp.m_pairManager.m_hashTable[i];
					while (index != b2Pair.b2_nullPair) {
						pair = bp.m_pairManager.m_pairs[index];
						p1 = bp.m_proxyPool[pair.proxyId1];
						p2 = bp.m_proxyPool[pair.proxyId2];
						b1.lowerBound.x = (bp.m_worldAABB.lowerBound.x + (invQ.x * bp.m_bounds[0][p1.lowerBounds[0]].value));
						b1.lowerBound.y = (bp.m_worldAABB.lowerBound.y + (invQ.y * bp.m_bounds[1][p1.lowerBounds[1]].value));
						b1.upperBound.x = (bp.m_worldAABB.lowerBound.x + (invQ.x * bp.m_bounds[0][p1.upperBounds[0]].value));
						b1.upperBound.y = (bp.m_worldAABB.lowerBound.y + (invQ.y * bp.m_bounds[1][p1.upperBounds[1]].value));
						b2.lowerBound.x = (bp.m_worldAABB.lowerBound.x + (invQ.x * bp.m_bounds[0][p2.lowerBounds[0]].value));
						b2.lowerBound.y = (bp.m_worldAABB.lowerBound.y + (invQ.y * bp.m_bounds[1][p2.lowerBounds[1]].value));
						b2.upperBound.x = (bp.m_worldAABB.lowerBound.x + (invQ.x * bp.m_bounds[0][p2.upperBounds[0]].value));
						b2.upperBound.y = (bp.m_worldAABB.lowerBound.y + (invQ.y * bp.m_bounds[1][p2.upperBounds[1]].value));
						x1.x = (0.5 * (b1.lowerBound.x + b1.upperBound.x));
						x1.y = (0.5 * (b1.lowerBound.y + b1.upperBound.y));
						x2.x = (0.5 * (b2.lowerBound.x + b2.upperBound.x));
						x2.y = (0.5 * (b2.lowerBound.y + b2.upperBound.y));
						m_debugDraw.DrawSegment(x1, x2, color);
						index = pair.next;
					};
					i++;
				};
			};
			if ((flags & b2DebugDraw.e_aabbBit)){
				bp = m_broadPhase;
				worldLower = bp.m_worldAABB.lowerBound;
				worldUpper = bp.m_worldAABB.upperBound;
				invQ.Set((1 / bp.m_quantizationFactor.x), (1 / bp.m_quantizationFactor.y));
				color.Set(0.9, 0.3, 0.9);
				i = 0;
				while (i < b2Settings.b2_maxProxies) {
					p = bp.m_proxyPool[i];
					if (p.IsValid() == false){
					} else {
						b1.lowerBound.x = (worldLower.x + (invQ.x * bp.m_bounds[0][p.lowerBounds[0]].value));
						b1.lowerBound.y = (worldLower.y + (invQ.y * bp.m_bounds[1][p.lowerBounds[1]].value));
						b1.upperBound.x = (worldLower.x + (invQ.x * bp.m_bounds[0][p.upperBounds[0]].value));
						b1.upperBound.y = (worldLower.y + (invQ.y * bp.m_bounds[1][p.upperBounds[1]].value));
						vs[0].Set(b1.lowerBound.x, b1.lowerBound.y);
						vs[1].Set(b1.upperBound.x, b1.lowerBound.y);
						vs[2].Set(b1.upperBound.x, b1.upperBound.y);
						vs[3].Set(b1.lowerBound.x, b1.upperBound.y);
						m_debugDraw.DrawPolygon(vs, 4, color);
					};
					i++;
				};
				vs[0].Set(worldLower.x, worldLower.y);
				vs[1].Set(worldUpper.x, worldLower.y);
				vs[2].Set(worldUpper.x, worldUpper.y);
				vs[3].Set(worldLower.x, worldUpper.y);
				m_debugDraw.DrawPolygon(vs, 4, new b2Color(0.3, 0.9, 0.9));
			};
			if ((flags & b2DebugDraw.e_obbBit)){
				color.Set(0.5, 0.3, 0.5);
				b = m_bodyList;
				while (b) {
					xf = b.m_xf;
					s = b.GetShapeList();
					while (s) {
						if (s.m_type != b2Shape.e_polygonShape){
						} else {
							poly = (s as b2PolygonShape);
							obb = poly.GetOBB();
							h = obb.extents;
							vs[0].Set(-(h.x), -(h.y));
							vs[1].Set(h.x, -(h.y));
							vs[2].Set(h.x, h.y);
							vs[3].Set(-(h.x), h.y);
							i = 0;
							while (i < 4) {
								tMat = obb.R;
								tVec = vs[i];
								tX = (obb.center.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
								vs[i].y = (obb.center.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
								vs[i].x = tX;
								tMat = xf.R;
								tX = (xf.position.x + ((tMat.col1.x * tVec.x) + (tMat.col2.x * tVec.y)));
								vs[i].y = (xf.position.y + ((tMat.col1.y * tVec.x) + (tMat.col2.y * tVec.y)));
								vs[i].x = tX;
								i++;
							};
							m_debugDraw.DrawPolygon(vs, 4, color);
						};
						s = s.m_next;
					};
					b = b.m_next;
				};
			};
			if ((flags & b2DebugDraw.e_centerOfMassBit)){
				b = m_bodyList;
				while (b) {
					xf = s_xf;
					xf.R = b.m_xf.R;
					xf.position = b.GetWorldCenter();
					m_debugDraw.DrawXForm(xf);
					b = b.m_next;
				};
			};
		}
		public function DestroyBody(b:b2Body):void{
			var jn0:b2JointEdge;
			var s0:b2Shape;
			if (m_lock == true){
				return;
			};
			var jn:b2JointEdge = b.m_jointList;
			while (jn) {
				jn0 = jn;
				jn = jn.next;
				if (m_destructionListener){
					m_destructionListener.SayGoodbyeJoint(jn0.joint);
				};
				DestroyJoint(jn0.joint);
			};
			var s:b2Shape = b.m_shapeList;
			while (s) {
				s0 = s;
				s = s.m_next;
				if (m_destructionListener){
					m_destructionListener.SayGoodbyeShape(s0);
				};
				s0.DestroyProxy(m_broadPhase);
				b2Shape.Destroy(s0, m_blockAllocator);
			};
			if (b.m_prev){
				b.m_prev.m_next = b.m_next;
			};
			if (b.m_next){
				b.m_next.m_prev = b.m_prev;
			};
			if (b == m_bodyList){
				m_bodyList = b.m_next;
			};
			m_bodyCount--;
		}
		public function SetContinuousPhysics(flag:Boolean):void{
			m_continuousPhysics = flag;
		}
		public function CreateGroundShape(def:b2ShapeDef){
			if (m_lock == true){
				return (null);
			};
			switch (def.type){
				case b2Shape.e_staticEdgeShape:
					return (new b2StaticEdgeChain(def, this));
				default:
					return (m_groundBody.CreateShape(def));
			};
		}
		public function GetGroundBody():b2Body{
			return (m_groundBody);
		}
		public function DrawShape(shape:b2Shape, xf:b2XForm, color:b2Color, core:Boolean):void{
			var circle:b2CircleShape;
			var center:b2Vec2;
			var radius:Number;
			var axis:b2Vec2;
			var i:int;
			var poly:b2PolygonShape;
			var vertexCount:int;
			var localVertices:Array;
			var vertices:Array;
			var localCoreVertices:Array;
			var arc:b2ConcaveArcShape;
			var edge:b2StaticEdgeShape;
			var coreColor:b2Color = s_coreColor;
			switch (shape.m_type){
				case b2Shape.e_circleShape:
					circle = (shape as b2CircleShape);
					center = b2Math.b2MulX(xf, circle.m_localPosition);
					radius = circle.m_radius;
					axis = xf.R.col1;
					m_debugDraw.DrawSolidCircle(center, radius, axis, color);
					if (core){
						m_debugDraw.DrawCircle(center, (radius - b2Settings.b2_toiSlop), coreColor);
					};
					break;
				case b2Shape.e_polygonShape:
					poly = (shape as b2PolygonShape);
					vertexCount = poly.GetVertexCount();
					localVertices = poly.GetVertices();
					vertices = new Array(b2Settings.b2_maxPolygonVertices);
					i = 0;
					while (i < vertexCount) {
						vertices[i] = b2Math.b2MulX(xf, localVertices[i]);
						i++;
					};
					m_debugDraw.DrawSolidPolygon(vertices, vertexCount, color);
					if (core){
						localCoreVertices = poly.GetCoreVertices();
						i = 0;
						while (i < vertexCount) {
							vertices[i] = b2Math.b2MulX(xf, localCoreVertices[i]);
							i++;
						};
						m_debugDraw.DrawPolygon(vertices, vertexCount, coreColor);
					};
					break;
				case b2Shape.e_concaveArcShape:
					arc = (shape as b2ConcaveArcShape);
					vertexCount = arc.GetVertexCount();
					localVertices = arc.GetVertices();
					center = b2Math.b2MulX(xf, arc.m_arcCenter);
					vertices = new Array(b2Settings.b2_maxPolygonVertices);
					i = 0;
					while (i < vertexCount) {
						vertices[i] = b2Math.b2MulX(xf, localVertices[i]);
						i++;
					};
					m_debugDraw.DrawSolidConcaveArc(vertices, vertexCount, center, color);
					if (core){
						localCoreVertices = arc.GetCoreVertices();
						i = 0;
						while (i < vertexCount) {
							vertices[i] = b2Math.b2MulX(xf, localCoreVertices[i]);
							i++;
						};
						m_debugDraw.DrawConcaveArc(vertices, vertexCount, center, coreColor);
					};
					break;
				case b2Shape.e_staticEdgeShape:
					edge = (shape as b2StaticEdgeShape);
					m_debugDraw.DrawSegment(edge.m_v1, edge.m_v2, color);
					if (core){
						m_debugDraw.DrawSegment(edge.m_coreV1, edge.m_coreV2, coreColor);
					};
					break;
			};
		}
		public function GetContactCount():int{
			return (m_contactCount);
		}
		public function Solve(step:b2TimeStep):void{
			var b:b2Body;
			var stackCount:int;
			var i:int;
			var other:b2Body;
			var cn:b2ContactEdge;
			var jn:b2JointEdge;
			var inRange:Boolean;
			m_positionIterationCount = 0;
			var island:b2Island = new b2Island(m_bodyCount, m_contactCount, m_jointCount, m_stackAllocator, m_contactListener);
			b = m_bodyList;
			while (b) {
				b.m_flags = (b.m_flags & ~(b2Body.e_islandFlag));
				b = b.m_next;
			};
			var c:b2Contact = m_contactList;
			while (c) {
				c.m_flags = (c.m_flags & ~(b2Contact.e_islandFlag));
				c = c.m_next;
			};
			var j:b2Joint = m_jointList;
			while (j) {
				j.m_islandFlag = false;
				j = j.m_next;
			};
			var stackSize:int = m_bodyCount;
			var stack:Array = new Array(stackSize);
			var seed:b2Body = m_bodyList;
			while (seed) {
				if ((seed.m_flags & ((b2Body.e_islandFlag | b2Body.e_sleepFlag) | b2Body.e_frozenFlag))){
				} else {
					if (seed.IsStatic()){
					} else {
						island.Clear();
						stackCount = 0;
						var _temp1 = stackCount;
						stackCount = (stackCount + 1);
						var _local15 = _temp1;
						stack[_local15] = seed;
						seed.m_flags = (seed.m_flags | b2Body.e_islandFlag);
						while (stackCount > 0) {
							--stackCount;
							b = stack[stackCount];
							island.AddBody(b);
							b.m_flags = (b.m_flags & ~(b2Body.e_sleepFlag));
							if (b.IsStatic()){
							} else {
								cn = b.m_contactList;
								while (cn) {
									if ((cn.contact.m_flags & (b2Contact.e_islandFlag | b2Contact.e_nonSolidFlag))){
									} else {
										if (cn.contact.m_manifoldCount == 0){
										} else {
											island.AddContact(cn.contact);
											cn.contact.m_flags = (cn.contact.m_flags | b2Contact.e_islandFlag);
											other = cn.other;
											if ((other.m_flags & b2Body.e_islandFlag)){
											} else {
												var _temp2 = stackCount;
												stackCount = (stackCount + 1);
												var _local16 = _temp2;
												stack[_local16] = other;
												other.m_flags = (other.m_flags | b2Body.e_islandFlag);
											};
										};
									};
									cn = cn.next;
								};
								jn = b.m_jointList;
								while (jn) {
									if (jn.joint.m_islandFlag == true){
									} else {
										island.AddJoint(jn.joint);
										jn.joint.m_islandFlag = true;
										other = jn.other;
										if ((other.m_flags & b2Body.e_islandFlag)){
										} else {
											var _temp3 = stackCount;
											stackCount = (stackCount + 1);
											_local16 = _temp3;
											stack[_local16] = other;
											other.m_flags = (other.m_flags | b2Body.e_islandFlag);
										};
									};
									jn = jn.next;
								};
							};
						};
						island.Solve(step, m_gravity, m_positionCorrection, m_allowSleep);
						if (island.m_positionIterationCount > m_positionIterationCount){
							m_positionIterationCount = island.m_positionIterationCount;
						};
						i = 0;
						while (i < island.m_bodyCount) {
							b = island.m_bodies[i];
							if (b.IsStatic()){
								b.m_flags = (b.m_flags & ~(b2Body.e_islandFlag));
							};
							i++;
						};
					};
				};
				seed = seed.m_next;
			};
			b = m_bodyList;
			while (b) {
				if ((b.m_flags & (b2Body.e_sleepFlag | b2Body.e_frozenFlag))){
				} else {
					if (b.IsStatic()){
					} else {
						inRange = b.SynchronizeShapes();
						if ((((inRange == false)) && (!((m_boundaryListener == null))))){
							m_boundaryListener.Violation(b);
						};
					};
				};
				b = b.m_next;
			};
			m_broadPhase.Commit();
		}
		public function Query(aabb:b2AABB, shapes:Array, maxCount:int):int{
			var results:Array = new Array(maxCount);
			var count:int = m_broadPhase.QueryAABB(aabb, results, maxCount);
			var i:int;
			while (i < count) {
				shapes[i] = results[i];
				i++;
			};
			return (count);
		}
		public function SetGravity(gravity:b2Vec2):void{
			m_gravity = gravity;
		}
		public function SolveTOI(step:b2TimeStep):void{
			var b:b2Body;
			var s1:b2Shape;
			var s2:b2Shape;
			var b1:b2Body;
			var b2:b2Body;
			var cn:b2ContactEdge;
			var c:b2Contact;
			var minContact:b2Contact;
			var minTOI:Number;
			var seed:b2Body;
			var stackCount:int;
			var subStep:b2TimeStep;
			var i:int;
			var toi:Number;
			var t0:Number;
			var other:b2Body;
			var inRange:Boolean;
			var island:b2Island = new b2Island(m_bodyCount, b2Settings.b2_maxTOIContactsPerIsland, 0, m_stackAllocator, m_contactListener);
			var stackSize:int = m_bodyCount;
			var stack:Array = new Array(stackSize);
			b = m_bodyList;
			while (b) {
				b.m_flags = (b.m_flags & ~(b2Body.e_islandFlag));
				b.m_sweep.t0 = 0;
				b = b.m_next;
			};
			c = m_contactList;
			while (c) {
				c.m_flags = (c.m_flags & ~((b2Contact.e_toiFlag | b2Contact.e_islandFlag)));
				c = c.m_next;
			};
			while (true) {
				minContact = null;
				minTOI = 1;
				c = m_contactList;
				for (;c;(c = c.m_next)) {
					if ((c.m_flags & (b2Contact.e_slowFlag | b2Contact.e_nonSolidFlag))){
					} else {
						toi = 1;
						if ((c.m_flags & b2Contact.e_toiFlag)){
							toi = c.m_toi;
						} else {
							s1 = c.m_shape1;
							s2 = c.m_shape2;
							b1 = s1.m_body;
							b2 = s2.m_body;
							if (((((b1.IsStatic()) || (b1.IsSleeping()))) && (((b2.IsStatic()) || (b2.IsSleeping()))))){
								continue;
							};
							t0 = b1.m_sweep.t0;
							if (b1.m_sweep.t0 < b2.m_sweep.t0){
								t0 = b2.m_sweep.t0;
								b1.m_sweep.Advance(t0);
							} else {
								if (b2.m_sweep.t0 < b1.m_sweep.t0){
									t0 = b1.m_sweep.t0;
									b2.m_sweep.Advance(t0);
								};
							};
							toi = b2TimeOfImpact.TimeOfImpact(c.m_shape1, b1.m_sweep, c.m_shape2, b2.m_sweep);
							if ((((toi > 0)) && ((toi < 1)))){
								toi = (((1 - toi) * t0) + toi);
								if (toi > 1){
									toi = 1;
								};
							};
							c.m_toi = toi;
							c.m_flags = (c.m_flags | b2Contact.e_toiFlag);
						};
						if ((((Number.MIN_VALUE < toi)) && ((toi < minTOI)))){
							minContact = c;
							minTOI = toi;
						};
					};
				};
				if ((((minContact == null)) || (((1 - (100 * Number.MIN_VALUE)) < minTOI)))){
					break;
				};
				s1 = minContact.m_shape1;
				s2 = minContact.m_shape2;
				b1 = s1.m_body;
				b2 = s2.m_body;
				b1.Advance(minTOI);
				b2.Advance(minTOI);
				minContact.Update(m_contactListener);
				minContact.m_flags = (minContact.m_flags & ~(b2Contact.e_toiFlag));
				if (minContact.m_manifoldCount == 0){
				} else {
					seed = b1;
					if (seed.IsStatic()){
						seed = b2;
					};
					island.Clear();
					stackCount = 0;
					var _temp1 = stackCount;
					stackCount = (stackCount + 1);
					var _local22 = _temp1;
					stack[_local22] = seed;
					seed.m_flags = (seed.m_flags | b2Body.e_islandFlag);
					while (stackCount > 0) {
						--stackCount;
						b = stack[stackCount];
						island.AddBody(b);
						b.m_flags = (b.m_flags & ~(b2Body.e_sleepFlag));
						if (b.IsStatic()){
						} else {
							cn = b.m_contactList;
							while (cn) {
								if (island.m_contactCount == island.m_contactCapacity){
								} else {
									if ((cn.contact.m_flags & ((b2Contact.e_islandFlag | b2Contact.e_slowFlag) | b2Contact.e_nonSolidFlag))){
									} else {
										if (cn.contact.m_manifoldCount == 0){
										} else {
											island.AddContact(cn.contact);
											cn.contact.m_flags = (cn.contact.m_flags | b2Contact.e_islandFlag);
											other = cn.other;
											if ((other.m_flags & b2Body.e_islandFlag)){
											} else {
												if (other.IsStatic() == false){
													other.Advance(minTOI);
													other.WakeUp();
												};
												var _temp2 = stackCount;
												stackCount = (stackCount + 1);
												var _local23 = _temp2;
												stack[_local23] = other;
												other.m_flags = (other.m_flags | b2Body.e_islandFlag);
											};
										};
									};
								};
								cn = cn.next;
							};
						};
					};
					subStep = new b2TimeStep();
					subStep.dt = ((1 - minTOI) * step.dt);
					subStep.inv_dt = (1 / subStep.dt);
					subStep.maxIterations = step.maxIterations;
					island.SolveTOI(subStep);
					i = 0;
					while (i < island.m_bodyCount) {
						b = island.m_bodies[i];
						b.m_flags = (b.m_flags & ~(b2Body.e_islandFlag));
						if ((b.m_flags & (b2Body.e_sleepFlag | b2Body.e_frozenFlag))){
						} else {
							if (b.IsStatic()){
							} else {
								inRange = b.SynchronizeShapes();
								if ((((inRange == false)) && (!((m_boundaryListener == null))))){
									m_boundaryListener.Violation(b);
								};
								cn = b.m_contactList;
								while (cn) {
									cn.contact.m_flags = (cn.contact.m_flags & ~(b2Contact.e_toiFlag));
									cn = cn.next;
								};
							};
						};
						i++;
					};
					i = 0;
					while (i < island.m_contactCount) {
						c = island.m_contacts[i];
						c.m_flags = (c.m_flags & ~((b2Contact.e_toiFlag | b2Contact.e_islandFlag)));
						i++;
					};
					m_broadPhase.Commit();
				};
			};
		}
		public function GetJointList():b2Joint{
			return (m_jointList);
		}
		public function Validate():void{
			m_broadPhase.Validate();
		}
		public function GetPairCount():int{
			return (m_broadPhase.m_pairManager.m_pairCount);
		}
		public function GetBodyList():b2Body{
			return (m_bodyList);
		}
		public function SetWarmStarting(flag:Boolean):void{
			m_warmStarting = flag;
		}
		public function SetPositionCorrection(flag:Boolean):void{
			m_positionCorrection = flag;
		}
		public function CreateJoint(def:b2JointDef):b2Joint{
			var b:b2Body;
			var s:b2Shape;
			var j:b2Joint = b2Joint.Create(def, m_blockAllocator);
			j.m_prev = null;
			j.m_next = m_jointList;
			if (m_jointList){
				m_jointList.m_prev = j;
			};
			m_jointList = j;
			m_jointCount++;
			j.m_node1.joint = j;
			j.m_node1.other = j.m_body2;
			j.m_node1.prev = null;
			j.m_node1.next = j.m_body1.m_jointList;
			if (j.m_body1.m_jointList){
				j.m_body1.m_jointList.prev = j.m_node1;
			};
			j.m_body1.m_jointList = j.m_node1;
			j.m_node2.joint = j;
			j.m_node2.other = j.m_body1;
			j.m_node2.prev = null;
			j.m_node2.next = j.m_body2.m_jointList;
			if (j.m_body2.m_jointList){
				j.m_body2.m_jointList.prev = j.m_node2;
			};
			j.m_body2.m_jointList = j.m_node2;
			if (def.collideConnected == false){
				b = ((def.body1.m_shapeCount < def.body2.m_shapeCount)) ? def.body1 : def.body2;
				s = b.m_shapeList;
				while (s) {
					s.RefilterProxy(m_broadPhase, b.m_xf);
					s = s.m_next;
				};
			};
			return (j);
		}
		public function DestroyJoint(j:b2Joint):void{
			var b:b2Body;
			var s:b2Shape;
			var collideConnected:Boolean = j.m_collideConnected;
			if (j.m_prev){
				j.m_prev.m_next = j.m_next;
			};
			if (j.m_next){
				j.m_next.m_prev = j.m_prev;
			};
			if (j == m_jointList){
				m_jointList = j.m_next;
			};
			var body1:b2Body = j.m_body1;
			var body2:b2Body = j.m_body2;
			body1.WakeUp();
			body2.WakeUp();
			if (j.m_node1.prev){
				j.m_node1.prev.next = j.m_node1.next;
			};
			if (j.m_node1.next){
				j.m_node1.next.prev = j.m_node1.prev;
			};
			if (j.m_node1 == body1.m_jointList){
				body1.m_jointList = j.m_node1.next;
			};
			j.m_node1.prev = null;
			j.m_node1.next = null;
			if (j.m_node2.prev){
				j.m_node2.prev.next = j.m_node2.next;
			};
			if (j.m_node2.next){
				j.m_node2.next.prev = j.m_node2.prev;
			};
			if (j.m_node2 == body2.m_jointList){
				body2.m_jointList = j.m_node2.next;
			};
			j.m_node2.prev = null;
			j.m_node2.next = null;
			b2Joint.Destroy(j, m_blockAllocator);
			m_jointCount--;
			if (collideConnected == false){
				b = ((body1.m_shapeCount < body2.m_shapeCount)) ? body1 : body2;
				s = b.m_shapeList;
				while (s) {
					s.RefilterProxy(m_broadPhase, b.m_xf);
					s = s.m_next;
				};
			};
		}
		public function SetContactListener(listener:b2ContactListener):void{
			m_contactListener = listener;
		}
		public function CreateBody(def:b2BodyDef):b2Body{
			if (m_lock == true){
				return (null);
			};
			var b:b2Body = new b2Body(def, this);
			b.m_prev = null;
			b.m_next = m_bodyList;
			if (m_bodyList){
				m_bodyList.m_prev = b;
			};
			m_bodyList = b;
			m_bodyCount++;
			return (b);
		}
		public function SetBoundaryListener(listener:b2BoundaryListener):void{
			m_boundaryListener = listener;
		}
		public function SetDestructionListener(listener:b2DestructionListener):void{
			m_destructionListener = listener;
		}
		public function Step(dt:Number, iterations:int):void{
			m_lock = true;
			var step:b2TimeStep = new b2TimeStep();
			step.dt = dt;
			step.maxIterations = iterations;
			if (dt > 0){
				step.inv_dt = (1 / dt);
			} else {
				step.inv_dt = 0;
			};
			step.dtRatio = (m_inv_dt0 * dt);
			step.positionCorrection = m_positionCorrection;
			step.warmStarting = m_warmStarting;
			m_contactManager.Collide();
			if (step.dt > 0){
				Solve(step);
			};
			if (((m_continuousPhysics) && ((step.dt > 0)))){
				SolveTOI(step);
			};
			DrawDebugData();
			m_inv_dt0 = step.inv_dt;
			m_lock = false;
		}
		public function GetBodyCount():int{
			return (m_bodyCount);
		}
		public function GetJointCount():int{
			return (m_jointCount);
		}

	}
}//package Box2D.Dynamics 
Section 86
//Transitions (com.boostworthy.animation.easing.Transitions)
package com.boostworthy.animation.easing {

	public final class Transitions {

		public static const SINE_OUT:String = "sineOut";
		public static const QUAD_IN_AND_OUT:String = "quadInAndOut";
		private static const ELASTIC_PERIOD:Number = 400;
		public static const QUART_OUT:String = "quartOut";
		public static const BOUNCE:String = "bounce";
		public static const EXPO_IN:String = "expoIn";
		public static const SINE_IN:String = "sineIn";
		public static const CUBIC_OUT:String = "cubicOut";
		public static const QUINT_OUT:String = "quintOut";
		public static const QUAD_IN:String = "quadIn";
		public static const QUINT_IN_AND_OUT:String = "quintInAndOut";
		public static const ELASTIC_OUT:String = "elasticOut";
		public static const LINEAR:String = "linear";
		public static const QUART_IN_AND_OUT:String = "quartInAndOut";
		public static const QUAD_OUT:String = "quadOut";
		public static const QUINT_IN:String = "quintIn";
		public static const CUBIC_IN_AND_OUT:String = "cubicInAndOut";
		public static const QUART_IN:String = "quartIn";
		public static const DEFAULT_TRANSITION:String = "linear";
		private static const BACK_OVERSHOOT:Number = 1.70158;
		public static const BACK_OUT:String = "backOut";
		private static const ELASTIC_AMPLITUDE:Number = undefined;
		public static const CUBIC_IN:String = "cubicIn";
		public static const ELASTIC_IN_AND_OUT:String = "elasticInAndOut";
		public static const EXPO_OUT:String = "expoOut";
		public static const BACK_IN_AND_OUT:String = "backInAndOut";
		public static const ELASTIC_IN:String = "elasticIn";
		public static const EXPO_IN_AND_OUT:String = "expoInAndOut";
		public static const BACK_IN:String = "backIn";
		public static const SINE_IN_AND_OUT:String = "sineInAndOut";

		public function Transitions(){
			super();
		}
		public static function quadOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return ((((-(c) * t) * (t - 2)) + b));
		}
		public static function expoOut(t:Number, b:Number, c:Number, d:Number):Number{
			return (((t)==d) ? (b + c) : ((c * (-(Math.pow(2, ((-10 * t) / d))) + 1)) + b));
		}
		public static function expoInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			if (t == 0){
				return (b);
			};
			if (t == d){
				return ((b + c));
			};
			t = (t / (d / 2));
			if (t < 1){
				return ((((c / 2) * Math.pow(2, (10 * (t - 1)))) + b));
			};
			--t;
			return ((((c / 2) * (-(Math.pow(2, (-10 * t))) + 2)) + b));
		}
		public static function quintOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((c * (((((t * t) * t) * t) * t) + 1)) + b));
		}
		public static function cubicIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return (((((c * t) * t) * t) + b));
		}
		public static function sineIn(t:Number, b:Number, c:Number, d:Number):Number{
			return ((((-(c) * Math.cos(((t / d) * (Math.PI / 2)))) + b) + c));
		}
		public static function sineOut(t:Number, b:Number, c:Number, d:Number):Number{
			return (((c * Math.sin(((t / d) * (Math.PI / 2)))) + b));
		}
		public static function quartOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((-(c) * ((((t * t) * t) * t) - 1)) + b));
		}
		public static function sineInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			return ((((-(c) / 2) * (Math.cos(((t / d) * Math.PI)) - 1)) + b));
		}
		public static function bounce(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			if (t < (1 / 2.75)){
				return (((c * ((7.5625 * t) * t)) + b));
			};
			if (t < (2 / 2.75)){
				t = (t - (1.5 / 2.75));
				return (((c * (((7.5625 * t) * t) + 0.75)) + b));
			};
			if (t < (2.5 / 2.75)){
				t = (t - (2.25 / 2.75));
				return (((c * (((7.5625 * t) * t) + 0.9375)) + b));
			};
			t = (t - (2.625 / 2.75));
			return (((c * (((7.5625 * t) * t) + 0.984375)) + b));
		}
		public static function backInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			var s:Number = BACK_OVERSHOOT;
			t = (t / (d / 2));
			if (t < 1){
				s = (s * 1.525);
				return ((((c / 2) * ((t * t) * (((s + 1) * t) - s))) + b));
			};
			t = (t - 2);
			s = (s * 1.525);
			return ((((c / 2) * (((t * t) * (((s + 1) * t) + s)) + 2)) + b));
		}
		public static function expoIn(t:Number, b:Number, c:Number, d:Number):Number{
			return (((t)==0) ? b : ((c * Math.pow(2, (10 * ((t / d) - 1)))) + b));
		}
		public static function cubicOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((c * (((t * t) * t) + 1)) + b));
		}
		public static function linear(t:Number, b:Number, c:Number, d:Number):Number{
			return ((((c * t) / d) + b));
		}
		public static function quadIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return ((((c * t) * t) + b));
		}
		public static function quintIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return (((((((c * t) * t) * t) * t) * t) + b));
		}
		public static function elasticOut(t:Number, b:Number, c:Number, d:Number):Number{
			var s:Number;
			var a:Number = ELASTIC_AMPLITUDE;
			var p:Number = ELASTIC_PERIOD;
			if (t == 0){
				return (b);
			};
			t = (t / d);
			if (t == 1){
				return ((b + c));
			};
			if (!p){
				p = (d * 0.3);
			};
			if (((!(a)) || ((a < Math.abs(c))))){
				a = c;
				s = (p / 4);
			} else {
				s = ((p / (2 * Math.PI)) * Math.asin((c / a)));
			};
			return (((((a * Math.pow(2, (-10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p))) + c) + b));
		}
		public static function quartInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return (((((((c / 2) * t) * t) * t) * t) + b));
			};
			t = (t - 2);
			return ((((-(c) / 2) * ((((t * t) * t) * t) - 2)) + b));
		}
		public static function quartIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return ((((((c * t) * t) * t) * t) + b));
		}
		public static function quadInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return (((((c / 2) * t) * t) + b));
			};
			--t;
			return ((((-(c) / 2) * ((t * (t - 2)) - 1)) + b));
		}
		public static function quintInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return ((((((((c / 2) * t) * t) * t) * t) * t) + b));
			};
			t = (t - 2);
			return ((((c / 2) * (((((t * t) * t) * t) * t) + 2)) + b));
		}
		public static function elasticIn(t:Number, b:Number, c:Number, d:Number):Number{
			var s:Number;
			var a:Number = ELASTIC_AMPLITUDE;
			var p:Number = ELASTIC_PERIOD;
			if (t == 0){
				return (b);
			};
			t = (t / d);
			if (t == 1){
				return ((b + c));
			};
			if (!p){
				p = (d * 0.3);
			};
			if (((!(a)) || ((a < Math.abs(c))))){
				a = c;
				s = (p / 4);
			} else {
				s = ((p / (2 * Math.PI)) * Math.asin((c / a)));
			};
			--t;
			return ((-(((a * Math.pow(2, (10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p)))) + b));
		}
		public static function cubicInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return ((((((c / 2) * t) * t) * t) + b));
			};
			t = (t - 2);
			return ((((c / 2) * (((t * t) * t) + 2)) + b));
		}
		public static function backOut(t:Number, b:Number, c:Number, d:Number):Number{
			var s:Number = BACK_OVERSHOOT;
			t = ((t / d) - 1);
			return (((c * (((t * t) * (((s + 1) * t) + s)) + 1)) + b));
		}
		public static function elasticInAndOut(t:Number, b:Number, c:Number, d:Number):Number{
			var s:Number;
			var a:Number = ELASTIC_AMPLITUDE;
			var p:Number = ELASTIC_PERIOD;
			if (t == 0){
				return (b);
			};
			t = (t / (d / 2));
			if (t == 2){
				return ((b + c));
			};
			if (!p){
				p = (d * (0.3 * 1.5));
			};
			if (((!(a)) || ((a < Math.abs(c))))){
				a = c;
				s = (p / 4);
			} else {
				s = ((p / (2 * Math.PI)) * Math.asin((c / a)));
			};
			if (t < 1){
				--t;
				return (((-0.5 * ((a * Math.pow(2, (10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p)))) + b));
			};
			--t;
			return ((((((a * Math.pow(2, (-10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p))) * 0.5) + c) + b));
		}
		public static function backIn(t:Number, b:Number, c:Number, d:Number):Number{
			var s:Number = BACK_OVERSHOOT;
			t = (t / d);
			return (((((c * t) * t) * (((s + 1) * t) - s)) + b));
		}

	}
}//package com.boostworthy.animation.easing 
Section 87
//Animation (com.boostworthy.animation.management.types.abstract.Animation)
package com.boostworthy.animation.management.types.abstract {

	public class Animation implements IAnimation {

		protected var m_objTarget:Object;
		protected var m_uRenderMethod:uint;
		protected var m_strProperty:String;

		public function Animation(objTarget:Object, strProperty:String, uRenderMethod:uint){
			super();
			m_objTarget = objTarget;
			m_strProperty = strProperty;
			m_uRenderMethod = uRenderMethod;
		}
		public function get method():uint{
			return (m_uRenderMethod);
		}
		public function get property():String{
			return (m_strProperty);
		}
		public function get target():Object{
			return (m_objTarget);
		}
		public function render():Boolean{
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types.abstract 
Section 88
//IAnimation (com.boostworthy.animation.management.types.abstract.IAnimation)
package com.boostworthy.animation.management.types.abstract {
	import com.boostworthy.animation.rendering.*;

	public interface IAnimation extends IRenderable {

		function get method():uint;
		function get target():Object;
		function get property():String;

	}
}//package com.boostworthy.animation.management.types.abstract 
Section 89
//AlphaAnimation (com.boostworthy.animation.management.types.AlphaAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class AlphaAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "alpha";

		public function AlphaAnimation(objTarget:DisplayObject, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = m_objTarget.alpha;
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_objTarget.visible = true;
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.alpha = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
				return (true);
			};
			m_objTarget.alpha = m_nTargetValue;
			if (!m_nTargetValue){
				m_objTarget.visible = false;
			};
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 90
//BlurAnimation (com.boostworthy.animation.management.types.BlurAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import flash.filters.*;
	import com.boostworthy.animation.easing.*;

	public class BlurAnimation extends Animation {

		protected var m_nStartTime:Number;
		protected var m_aFilters:Array;
		protected var m_fncTransition:Function;
		protected var m_objBlur:BlurFilter;
		protected var m_nStartValueX:Number;
		protected var m_nStartValueY:Number;
		protected var m_nDuration:Number;
		protected var m_nChangeValueX:Number;
		protected var m_nTargetValueX:Number;
		protected var m_nTargetValueY:Number;
		protected var m_nChangeValueY:Number;

		protected static const DEFAULT_QUALITY:Number = 3;
		public static const PROPERTY:String = "filters.BlurFilter.blurX, filters.BlurFilter.blurY";
		protected static const DEFAULT_BLUR_X:Number = 0;
		protected static const DEFAULT_BLUR_Y:Number = 0;

		public function BlurAnimation(objTarget:DisplayObject, nTargetValueX:Number, nTargetValueY:Number, nQuality:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			var i:Number;
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValueX = nTargetValueX;
			m_nTargetValueY = nTargetValueY;
			m_nDuration = nDuration;
			m_aFilters = new Array();
			if (m_objTarget.filters.length){
				i = 0;
				while (i < m_objTarget.filters.length) {
					if ((m_objTarget.filters[i] is BlurFilter)){
						m_objBlur = m_objTarget.filters[i].clone();
					} else {
						m_aFilters.push(m_objTarget.filters[i]);
					};
					i++;
				};
			} else {
				m_objBlur = new BlurFilter(DEFAULT_BLUR_X, DEFAULT_BLUR_Y, nQuality);
			};
			m_fncTransition = Transitions[strTransition];
			m_nStartValueX = m_objBlur.blurX;
			m_nStartValueY = m_objBlur.blurY;
			m_nChangeValueX = (m_nTargetValueX - m_nStartValueX);
			m_nChangeValueY = (m_nTargetValueY - m_nStartValueY);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var aFilters:Array;
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				aFilters = m_aFilters.concat();
				m_objBlur.blurX = m_fncTransition(nTime, m_nStartValueX, m_nChangeValueX, m_nDuration);
				m_objBlur.blurY = m_fncTransition(nTime, m_nStartValueY, m_nChangeValueY, m_nDuration);
				aFilters.push(m_objBlur);
				m_objTarget.filters = aFilters;
				return (true);
			};
			m_objBlur.blurX = m_nTargetValueX;
			m_objBlur.blurY = m_nTargetValueY;
			m_aFilters.push(m_objBlur);
			m_objTarget.filters = m_aFilters;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 91
//BrightnessAnimation (com.boostworthy.animation.management.types.BrightnessAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.core.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class BrightnessAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "colorMatrix.brightness";

		public function BrightnessAnimation(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = objTarget.colorMatrix.brightness;
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.colorMatrix.brightness = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
				return (true);
			};
			m_objTarget.colorMatrix.brightness = m_nTargetValue;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 92
//ColorAnimation (com.boostworthy.animation.management.types.ColorAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.geom.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class ColorAnimation extends Animation {

		protected var m_nChangeValueG:Number;
		protected var m_nStartValueR:Number;
		protected var m_nStartValueG:Number;
		protected var m_nChangeValueR:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_nTargetValueB:Number;
		protected var m_nTargetValueG:Number;
		protected var m_nTargetValueR:Number;
		protected var m_nStartValueB:Number;
		protected var m_nChangeValueB:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "transform.colorTransform.redOffset, transform.colorTransform.greenOffset, transform.colorTransform.blueOffset";

		public function ColorAnimation(objTarget:DisplayObject, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			var objColor:ColorTransform = new ColorTransform(0, 0, 0, 1, 0, 0, 0, NaN);
			objColor.color = nTargetValue;
			m_nTargetValueR = objColor.redOffset;
			m_nTargetValueG = objColor.greenOffset;
			m_nTargetValueB = objColor.blueOffset;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValueR = m_objTarget.transform.colorTransform.redOffset;
			m_nStartValueG = m_objTarget.transform.colorTransform.greenOffset;
			m_nStartValueB = m_objTarget.transform.colorTransform.blueOffset;
			m_nChangeValueR = (m_nTargetValueR - m_nStartValueR);
			m_nChangeValueG = (m_nTargetValueG - m_nStartValueG);
			m_nChangeValueB = (m_nTargetValueB - m_nStartValueB);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var objColor:ColorTransform = new ColorTransform(0, 0, 0, 1, 0, 0, 0, NaN);
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				objColor.redOffset = m_fncTransition(nTime, m_nStartValueR, m_nChangeValueR, m_nDuration);
				objColor.greenOffset = m_fncTransition(nTime, m_nStartValueG, m_nChangeValueG, m_nDuration);
				objColor.blueOffset = m_fncTransition(nTime, m_nStartValueB, m_nChangeValueB, m_nDuration);
				m_objTarget.transform.colorTransform = objColor;
				return (true);
			};
			objColor.redOffset = m_nTargetValueR;
			objColor.greenOffset = m_nTargetValueG;
			objColor.blueOffset = m_nTargetValueB;
			m_objTarget.transform.colorTransform = objColor;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 93
//ContrastAnimation (com.boostworthy.animation.management.types.ContrastAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.core.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class ContrastAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "colorMatrix.contrast";

		public function ContrastAnimation(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = objTarget.colorMatrix.contrast;
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.colorMatrix.contrast = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
				return (true);
			};
			m_objTarget.colorMatrix.contrast = m_nTargetValue;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 94
//FilterAnimation (com.boostworthy.animation.management.types.FilterAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import flash.filters.*;
	import com.boostworthy.animation.easing.*;

	public class FilterAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_objFilter:Class;
		protected var m_fncTransition:Function;

		public function FilterAnimation(objTarget:DisplayObject, objFilter:Class, strProperty:String, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, strProperty, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_objFilter = objFilter;
			var iLength:int = m_objTarget.filters.length;
			var i:int;
			while (i < iLength) {
				if ((m_objTarget.filters[i] is m_objFilter)){
					m_nStartValue = m_objTarget.filters[i][m_strProperty];
				};
				i++;
			};
			if (isNaN(m_nStartValue)){
				throw (new Error("ERROR -> FilterAnimation :: Constructor :: An invalid filter and/or filter property was specified."));
			};
			m_fncTransition = Transitions[strTransition];
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_nStartTime = getTimer();
		}
		protected function updateTargetFliter(nValue:Number):void{
			var aFilters:Array = getFilters();
			var objFilter:BitmapFilter = getTargetFilter();
			objFilter[m_strProperty] = nValue;
			aFilters.push(objFilter);
			m_objTarget.filters = aFilters;
		}
		protected function getFilters():Array{
			var aFilters:Array = new Array();
			var iLength:int = m_objTarget.filters.length;
			var i:int;
			while (i < iLength) {
				if (!(m_objTarget.filters[i] is m_objFilter)){
					aFilters.push(m_objTarget.filters[i]);
				};
				i++;
			};
			return (aFilters);
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				updateTargetFliter(m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration));
				return (true);
			};
			updateTargetFliter(m_nTargetValue);
			return (false);
		}
		protected function getTargetFilter():BitmapFilter{
			var iLength:int = m_objTarget.filters.length;
			var i:int;
			while (i < iLength) {
				if ((m_objTarget.filters[i] is m_objFilter)){
					return (m_objTarget.filters[i]);
				};
				i++;
			};
			return (null);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 95
//FunctionsAnimation (com.boostworthy.animation.management.types.FunctionsAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class FunctionsAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncSet:Function;
		protected var m_fncTransition:Function;

		public function FunctionsAnimation(objTarget:Object, strGetFunction:String, strSetFunction:String, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, (((strGetFunction + "(), ") + strSetFunction) + "()"), uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = m_objTarget[strGetFunction]();
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_fncSet = m_objTarget[strSetFunction];
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_fncSet(m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration));
				return (true);
			};
			m_fncSet(m_nTargetValue);
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 96
//HueAnimation (com.boostworthy.animation.management.types.HueAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.core.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class HueAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "colorMatrix.hue";

		public function HueAnimation(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = objTarget.colorMatrix.hue;
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.colorMatrix.hue = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
				return (true);
			};
			m_objTarget.colorMatrix.hue = m_nTargetValue;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 97
//MoveAnimation (com.boostworthy.animation.management.types.MoveAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class MoveAnimation extends Animation {

		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;
		protected var m_nStartValueX:Number;
		protected var m_nStartValueY:Number;
		protected var m_nDuration:Number;
		protected var m_nChangeValueX:Number;
		protected var m_nTargetValueX:Number;
		protected var m_nTargetValueY:Number;
		protected var m_nChangeValueY:Number;

		public static const PROPERTY:String = "x, y";

		public function MoveAnimation(objTarget:DisplayObject, nTargetValueX:Number, nTargetValueY:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValueX = nTargetValueX;
			m_nTargetValueY = nTargetValueY;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValueX = m_objTarget.x;
			m_nStartValueY = m_objTarget.y;
			m_nChangeValueX = (m_nTargetValueX - m_nStartValueX);
			m_nChangeValueY = (m_nTargetValueY - m_nStartValueY);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.x = m_fncTransition(nTime, m_nStartValueX, m_nChangeValueX, m_nDuration);
				m_objTarget.y = m_fncTransition(nTime, m_nStartValueY, m_nChangeValueY, m_nDuration);
				return (true);
			};
			m_objTarget.x = m_nTargetValueX;
			m_objTarget.y = m_nTargetValueY;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 98
//PropertyAnimation (com.boostworthy.animation.management.types.PropertyAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class PropertyAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;

		public function PropertyAnimation(objTarget:Object, strProperty:String, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, strProperty, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = m_objTarget[m_strProperty];
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget[m_strProperty] = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
				return (true);
			};
			m_objTarget[m_strProperty] = m_nTargetValue;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 99
//PulseAnimation (com.boostworthy.animation.management.types.PulseAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;

	public class PulseAnimation extends Animation {

		protected var m_nMax:Number;
		protected var m_nMedian:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_nValue:Number;
		protected var m_nMin:Number;

		public function PulseAnimation(objTarget:Object, strProperty:String, nMin:Number, nMax:Number, nDuration:Number, uRenderMethod:uint){
			super(objTarget, strProperty, uRenderMethod);
			m_nMin = nMin;
			m_nMax = nMax;
			m_nDuration = nDuration;
			m_nValue = ((m_nMax - m_nMin) / 2);
			m_nMedian = (m_nMin + m_nValue);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			m_objTarget[m_strProperty] = (m_nMedian + (Math.cos(((nTime / m_nDuration) * (Math.PI * 2))) * m_nValue));
			return (true);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 100
//RotationAnimation (com.boostworthy.animation.management.types.RotationAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class RotationAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_uNumRepeats:uint;
		protected var m_uRepeatCount:uint;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "rotation";

		public function RotationAnimation(objTarget:DisplayObject, nTargetValue:Number, nDuration:Number, uNumRepeats:uint, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_uNumRepeats = uNumRepeats;
			m_uRepeatCount = 0;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = m_objTarget.rotation;
			m_nChangeValue = ((m_uNumRepeats)==1) ? (m_nTargetValue - m_nStartValue) : m_nTargetValue;
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.rotation = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
			} else {
				if (((!((m_uNumRepeats == 0))) && ((++m_uRepeatCount == m_uNumRepeats)))){
					m_objTarget.rotation = m_nTargetValue;
					return (false);
				};
				m_nStartValue = m_objTarget.rotation;
				m_nStartTime = getTimer();
			};
			return (true);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 101
//SaturationAnimation (com.boostworthy.animation.management.types.SaturationAnimation)
package com.boostworthy.animation.management.types {
	import flash.utils.*;
	import com.boostworthy.core.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class SaturationAnimation extends Animation {

		protected var m_nTargetValue:Number;
		protected var m_nChangeValue:Number;
		protected var m_nStartValue:Number;
		protected var m_nDuration:Number;
		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "colorMatrix.saturation";

		public function SaturationAnimation(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValue = nTargetValue;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValue = objTarget.colorMatrix.saturation;
			m_nChangeValue = (m_nTargetValue - m_nStartValue);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.colorMatrix.saturation = m_fncTransition(nTime, m_nStartValue, m_nChangeValue, m_nDuration);
				return (true);
			};
			m_objTarget.colorMatrix.saturation = m_nTargetValue;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 102
//ScaleAnimation (com.boostworthy.animation.management.types.ScaleAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class ScaleAnimation extends Animation {

		protected var m_nStartTime:Number;
		protected var m_fncTransition:Function;
		protected var m_nStartValueX:Number;
		protected var m_nStartValueY:Number;
		protected var m_nDuration:Number;
		protected var m_nChangeValueX:Number;
		protected var m_nTargetValueX:Number;
		protected var m_nTargetValueY:Number;
		protected var m_nChangeValueY:Number;

		public static const PROPERTY:String = "scaleX, scaleY";

		public function ScaleAnimation(objTarget:DisplayObject, nTargetValueX:Number, nTargetValueY:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValueX = nTargetValueX;
			m_nTargetValueY = nTargetValueY;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValueX = m_objTarget.scaleX;
			m_nStartValueY = m_objTarget.scaleY;
			m_nChangeValueX = (m_nTargetValueX - m_nStartValueX);
			m_nChangeValueY = (m_nTargetValueY - m_nStartValueY);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.scaleX = m_fncTransition(nTime, m_nStartValueX, m_nChangeValueX, m_nDuration);
				m_objTarget.scaleY = m_fncTransition(nTime, m_nStartValueY, m_nChangeValueY, m_nDuration);
				return (true);
			};
			m_objTarget.scaleX = m_nTargetValueX;
			m_objTarget.scaleY = m_nTargetValueY;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 103
//SizeAnimation (com.boostworthy.animation.management.types.SizeAnimation)
package com.boostworthy.animation.management.types {
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.easing.*;

	public class SizeAnimation extends Animation {

		protected var m_nStartTime:Number;
		protected var m_nChangeValueH:Number;
		protected var m_nTargetValueH:Number;
		protected var m_nStartValueW:Number;
		protected var m_nDuration:Number;
		protected var m_nChangeValueW:Number;
		protected var m_nTargetValueW:Number;
		protected var m_nStartValueH:Number;
		protected var m_fncTransition:Function;

		public static const PROPERTY:String = "width, height";

		public function SizeAnimation(objTarget:DisplayObject, nTargetValueW:Number, nTargetValueH:Number, nDuration:Number, strTransition:String, uRenderMethod:uint){
			super(objTarget, PROPERTY, uRenderMethod);
			m_nTargetValueW = nTargetValueW;
			m_nTargetValueH = nTargetValueH;
			m_nDuration = nDuration;
			m_fncTransition = Transitions[strTransition];
			m_nStartValueW = m_objTarget.width;
			m_nStartValueH = m_objTarget.height;
			m_nChangeValueW = (m_nTargetValueW - m_nStartValueW);
			m_nChangeValueH = (m_nTargetValueH - m_nStartValueH);
			m_nStartTime = getTimer();
		}
		override public function render():Boolean{
			var nTime:Number = (getTimer() - m_nStartTime);
			if (nTime < m_nDuration){
				m_objTarget.width = m_fncTransition(nTime, m_nStartValueW, m_nChangeValueW, m_nDuration);
				m_objTarget.height = m_fncTransition(nTime, m_nStartValueH, m_nChangeValueH, m_nDuration);
				return (true);
			};
			m_objTarget.width = m_nTargetValueW;
			m_objTarget.height = m_nTargetValueH;
			return (false);
		}

	}
}//package com.boostworthy.animation.management.types 
Section 104
//AnimationManager (com.boostworthy.animation.management.AnimationManager)
package com.boostworthy.animation.management {
	import flash.events.*;
	import flash.display.*;
	import flash.geom.*;
	import com.boostworthy.core.*;
	import com.boostworthy.animation.management.types.*;
	import com.boostworthy.animation.*;

	public class AnimationManager implements IEventDispatcher, IDisposable {

		protected const DEFAULT_REFRESH_RATE:Number = 10;
		protected const DEFAULT_RENDER_METHOD:uint = 2;
		protected const DEFAULT_TRANSITION:String = "linear";

		protected var m_objFramebuffer:Framebuffer;

		public function AnimationManager(){
			super();
			init();
		}
		public function dispatchEvent(objEvent:Event):Boolean{
			return (m_objFramebuffer.dispatchEvent(objEvent));
		}
		public function size(objTarget:DisplayObject, nTargetValueW:Number, nTargetValueH:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new SizeAnimation(objTarget, nTargetValueW, nTargetValueH, nDuration, strTransition, uRenderMethod));
		}
		public function willTrigger(strType:String):Boolean{
			return (m_objFramebuffer.willTrigger(strType));
		}
		public function contrast(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new ContrastAnimation(objTarget, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function scale(objTarget:DisplayObject, nTargetValueX:Number, nTargetValueY:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new ScaleAnimation(objTarget, nTargetValueX, nTargetValueY, nDuration, strTransition, uRenderMethod));
		}
		public function remove(objTarget:Object):void{
			m_objFramebuffer.removeBufferObject(objTarget);
		}
		public function addEventListener(strType:String, fncListener:Function, bUseCapture:Boolean=false, iPriority:int=0, bUseWeakReference:Boolean=false):void{
			m_objFramebuffer.addEventListener(strType, fncListener, bUseCapture, iPriority, bUseWeakReference);
		}
		public function brightness(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new BrightnessAnimation(objTarget, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function saturation(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new SaturationAnimation(objTarget, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function property(objTarget:Object, strProperty:String, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new PropertyAnimation(objTarget, strProperty, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		protected function init():void{
			BoostworthyAnimation.log();
			m_objFramebuffer = new Framebuffer(DEFAULT_REFRESH_RATE);
		}
		public function move(objTarget:DisplayObject, nTargetValueX:Number, nTargetValueY:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new MoveAnimation(objTarget, nTargetValueX, nTargetValueY, nDuration, strTransition, uRenderMethod));
		}
		public function pulse(objTarget:Object, strProperty:String, nMin:Number, nMax:Number, nDuration:Number, uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new PulseAnimation(objTarget, strProperty, nMin, nMax, nDuration, uRenderMethod));
		}
		public function functions(objTarget:Object, strGetFunction:String, strSetFunction:String, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new FunctionsAnimation(objTarget, strGetFunction, strSetFunction, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function alpha(objTarget:DisplayObject, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new AlphaAnimation(objTarget, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function dispose():void{
			m_objFramebuffer.dispose();
			m_objFramebuffer = null;
		}
		public function initColor(objTarget:DisplayObject, nColorValue:Number):void{
			var objColor:ColorTransform = new ColorTransform(0, 0, 0, 1, 0, 0, 0, NaN);
			objColor.color = nColorValue;
			objTarget.transform.colorTransform = objColor;
		}
		public function removeEventListener(strType:String, fncListener:Function, bUseCapture:Boolean=false):void{
			m_objFramebuffer.removeEventListener(strType, fncListener, bUseCapture);
		}
		public function color(objTarget:DisplayObject, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new ColorAnimation(objTarget, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function blur(objTarget:DisplayObject, nTargetValueX:Number, nTargetValueY:Number, nQuality:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new BlurAnimation(objTarget, nTargetValueX, nTargetValueY, nQuality, nDuration, strTransition, uRenderMethod));
		}
		protected function setStageReference(objTarget:DisplayObject):void{
			if (!Global.stage){
				Global.stage = objTarget.stage;
			};
		}
		public function hasEventListener(strType:String):Boolean{
			return (m_objFramebuffer.hasEventListener(strType));
		}
		public function filter(objTarget:DisplayObject, objFilter:Class, strProperty:String, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new FilterAnimation(objTarget, objFilter, strProperty, nTargetValue, nDuration, strTransition, uRenderMethod));
		}
		public function removeAll():void{
			m_objFramebuffer.clearBuffer();
		}
		public function rotation(objTarget:DisplayObject, nTargetValue:Number, nDuration:Number, uNumRepeats:uint=1, strTransition:String="linear", uRenderMethod:uint=2):void{
			setStageReference(objTarget);
			m_objFramebuffer.addBufferObject(new RotationAnimation(objTarget, nTargetValue, nDuration, uNumRepeats, strTransition, uRenderMethod));
		}
		public function hue(objTarget:IColorable, nTargetValue:Number, nDuration:Number, strTransition:String="linear", uRenderMethod:uint=2):void{
			if ((objTarget is DisplayObject)){
				setStageReference((objTarget as DisplayObject));
			};
			m_objFramebuffer.addBufferObject(new HueAnimation(objTarget, nTargetValue, nDuration, strTransition, uRenderMethod));
		}

	}
}//package com.boostworthy.animation.management 
Section 105
//Buffer (com.boostworthy.animation.management.Buffer)
package com.boostworthy.animation.management {
	import flash.events.*;
	import com.boostworthy.core.*;
	import com.boostworthy.events.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.collections.iterators.*;
	import com.boostworthy.collections.*;
	import com.boostworthy.animation.rendering.*;

	public class Buffer extends EventDispatcher implements ICollection, IDisposable, IRenderable {

		protected var m_objQueue:Queue;

		public function Buffer(){
			super();
			init();
		}
		public function add(objAnimation:IAnimation):void{
			m_objQueue.addElement(objAnimation);
		}
		public function remove(objAnimation:IAnimation):void{
			var objElement:IAnimation;
			var objIterator:IIterator = getIterator();
			while (objIterator.hasNext()) {
				objElement = (objIterator.next() as IAnimation);
				if (objElement === objAnimation){
					removeElement(objElement);
					break;
				};
			};
		}
		public function get length():uint{
			return (m_objQueue.length);
		}
		protected function removeElement(objElement:IAnimation):void{
			dispatchEvent(new AnimationEvent(AnimationEvent.STOP, objElement.target, objElement.property));
			m_objQueue.removeElement(objElement);
		}
		public function getIterator(uIterator:uint=2):IIterator{
			return (m_objQueue.getIterator(uIterator));
		}
		public function removeByTarget(objTarget:Object):void{
			var objElement:IAnimation;
			var objIterator:IIterator = getIterator(IteratorType.ARRAY_REVERSE);
			while (objIterator.hasNext()) {
				objElement = (objIterator.next() as IAnimation);
				if (objElement.target === objTarget){
					removeElement(objElement);
				};
			};
		}
		public function clear():void{
			var objElement:IAnimation;
			var objIterator:IIterator = getIterator();
			while (objIterator.hasNext()) {
				objElement = (objIterator.next() as IAnimation);
				dispatchEvent(new AnimationEvent(AnimationEvent.STOP, objElement.target, objElement.property));
			};
			m_objQueue.dispose();
		}
		public function removeByProperty(objTarget:Object, strProperty:String):void{
			var objElement:IAnimation;
			var objIterator:IIterator = getIterator();
			while (objIterator.hasNext()) {
				objElement = (objIterator.next() as IAnimation);
				if ((((objElement.target === objTarget)) && ((objElement.property == strProperty)))){
					removeElement(objElement);
					break;
				};
			};
		}
		public function render():Boolean{
			var objElement:IAnimation;
			var objIterator:IIterator = getIterator();
			while (objIterator.hasNext()) {
				objElement = (objIterator.next() as IAnimation);
				dispatchEvent(new AnimationEvent(AnimationEvent.CHANGE, objElement.target, objElement.property));
				if (!objElement.render()){
					dispatchEvent(new AnimationEvent(AnimationEvent.FINISH, objElement.target, objElement.property));
					m_objQueue.removeElement(objElement);
				};
			};
			return (true);
		}
		protected function init():void{
			m_objQueue = new Queue();
		}
		public function dispose():void{
			clear();
			m_objQueue = null;
		}

	}
}//package com.boostworthy.animation.management 
Section 106
//Framebuffer (com.boostworthy.animation.management.Framebuffer)
package com.boostworthy.animation.management {
	import flash.events.*;
	import com.boostworthy.core.*;
	import com.boostworthy.events.*;
	import com.boostworthy.animation.management.types.abstract.*;
	import com.boostworthy.animation.rendering.*;
	import com.boostworthy.animation.*;

	public class Framebuffer extends EventDispatcher implements IDisposable {

		protected var m_objBufferEF:Buffer;
		protected var m_objRenderer:Renderer;
		protected var m_objBufferT:Buffer;

		public function Framebuffer(nRefreshRate:Number){
			super();
			init(nRefreshRate);
		}
		public function addBufferObject(objAnimation:IAnimation):void{
			removeAnimationByProperty(objAnimation.target, objAnimation.property);
			dispatchEvent(new AnimationEvent(AnimationEvent.START, objAnimation.target, objAnimation.property));
			if (objAnimation.method == RenderMethod.ENTER_FRAME){
				m_objBufferEF.add(objAnimation);
				m_objRenderer.start(RenderMethod.ENTER_FRAME);
			} else {
				if (objAnimation.method == RenderMethod.TIMER){
					m_objBufferT.add(objAnimation);
					m_objRenderer.start(RenderMethod.TIMER);
				};
			};
		}
		protected function removeAnimation(objAnimation:IAnimation):void{
			if (objAnimation.method == RenderMethod.ENTER_FRAME){
				m_objBufferEF.remove(objAnimation);
				checkBufferLengthEF();
			} else {
				if (objAnimation.method == RenderMethod.TIMER){
					m_objBufferT.remove(objAnimation);
					checkBufferLengthT();
				};
			};
		}
		public function removeBufferObject(objTarget:Object):void{
			removeAnimationByObject(objTarget);
		}
		protected function removeAnimationByObject(objTarget:Object):void{
			m_objBufferEF.removeByTarget(objTarget);
			checkBufferLengthEF();
			m_objBufferT.removeByTarget(objTarget);
			checkBufferLengthT();
		}
		protected function onAnimationStop(objEvent:AnimationEvent):void{
			dispatchEvent(new AnimationEvent(AnimationEvent.STOP, objEvent.animTarget, objEvent.animProperty));
		}
		public function clearBuffer():void{
			m_objRenderer.stopAll();
			m_objBufferEF.clear();
			m_objBufferT.clear();
		}
		public function dispose():void{
			m_objBufferEF.removeEventListener(AnimationEvent.START, onAnimationStart);
			m_objBufferEF.removeEventListener(AnimationEvent.CHANGE, onAnimationChange);
			m_objBufferEF.removeEventListener(AnimationEvent.STOP, onAnimationStop);
			m_objBufferEF.removeEventListener(AnimationEvent.FINISH, onAnimationFinish);
			m_objBufferT.removeEventListener(AnimationEvent.START, onAnimationStart);
			m_objBufferT.removeEventListener(AnimationEvent.CHANGE, onAnimationChange);
			m_objBufferT.removeEventListener(AnimationEvent.STOP, onAnimationStop);
			m_objBufferT.removeEventListener(AnimationEvent.FINISH, onAnimationFinish);
			m_objBufferEF.dispose();
			m_objBufferT.dispose();
			m_objRenderer.dispose();
			m_objBufferEF = null;
			m_objBufferT = null;
			m_objRenderer = null;
		}
		protected function checkBufferLengthEF():void{
			if (!m_objBufferEF.length){
				m_objRenderer.stop(RenderMethod.ENTER_FRAME);
			};
		}
		protected function init(nRefreshRate:Number):void{
			BoostworthyAnimation.log();
			m_objBufferEF = new Buffer();
			m_objBufferT = new Buffer();
			m_objRenderer = new Renderer(onRenderEF, onRenderT, nRefreshRate);
			m_objBufferEF.addEventListener(AnimationEvent.START, onAnimationStart);
			m_objBufferEF.addEventListener(AnimationEvent.CHANGE, onAnimationChange);
			m_objBufferEF.addEventListener(AnimationEvent.STOP, onAnimationStop);
			m_objBufferEF.addEventListener(AnimationEvent.FINISH, onAnimationFinish);
			m_objBufferT.addEventListener(AnimationEvent.START, onAnimationStart);
			m_objBufferT.addEventListener(AnimationEvent.CHANGE, onAnimationChange);
			m_objBufferT.addEventListener(AnimationEvent.STOP, onAnimationStop);
			m_objBufferT.addEventListener(AnimationEvent.FINISH, onAnimationFinish);
		}
		protected function onAnimationChange(objEvent:AnimationEvent):void{
			dispatchEvent(new AnimationEvent(AnimationEvent.CHANGE, objEvent.animTarget, objEvent.animProperty));
		}
		protected function onRenderEF(objEvent:Event):void{
			m_objBufferEF.render();
			checkBufferLengthEF();
		}
		protected function onAnimationFinish(objEvent:AnimationEvent):void{
			dispatchEvent(new AnimationEvent(AnimationEvent.FINISH, objEvent.animTarget, objEvent.animProperty));
		}
		protected function checkBufferLengthT():void{
			if (!m_objBufferT.length){
				m_objRenderer.stop(RenderMethod.TIMER);
			};
		}
		protected function removeAnimationByProperty(objTarget:Object, strProperty:String):void{
			m_objBufferEF.removeByProperty(objTarget, strProperty);
			checkBufferLengthEF();
			m_objBufferT.removeByProperty(objTarget, strProperty);
			checkBufferLengthT();
		}
		protected function onAnimationStart(objEvent:AnimationEvent):void{
			dispatchEvent(new AnimationEvent(AnimationEvent.START, objEvent.animTarget, objEvent.animProperty));
		}
		protected function onRenderT(objEvent:TimerEvent):void{
			m_objBufferT.render();
			objEvent.updateAfterEvent();
			checkBufferLengthT();
		}

	}
}//package com.boostworthy.animation.management 
Section 107
//IRenderable (com.boostworthy.animation.rendering.IRenderable)
package com.boostworthy.animation.rendering {

	public interface IRenderable {

		function render():Boolean;

	}
}//package com.boostworthy.animation.rendering 
Section 108
//Renderer (com.boostworthy.animation.rendering.Renderer)
package com.boostworthy.animation.rendering {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;
	import com.boostworthy.core.*;
	import com.boostworthy.utils.logger.*;

	public class Renderer extends EventDispatcher implements IDisposable {

		protected var m_objTimer:Timer;
		protected var m_fncOnTimer:Function;
		protected var m_objStage:Stage;
		protected var m_fncOnEnterFrame:Function;
		protected var m_objLog:ILog;

		public function Renderer(fncOnEnterFrame:Function, fncOnTimer:Function, nRefreshRate:Number){
			super();
			if (fncOnEnterFrame != null){
				m_fncOnEnterFrame = fncOnEnterFrame;
				m_objStage = Global.stage;
			};
			if (fncOnTimer != null){
				m_fncOnTimer = fncOnTimer;
				m_objTimer = new Timer(nRefreshRate, 0);
				m_objTimer.addEventListener(TimerEvent.TIMER, m_fncOnTimer);
			};
			m_objLog = LogFactory.getInstance().getLog("Renderer");
		}
		public function start(nRenderMethod:Number):void{
			if (nRenderMethod == RenderMethod.ENTER_FRAME){
				startEnterFrame();
			} else {
				if (nRenderMethod == RenderMethod.TIMER){
					startTimer();
				};
			};
		}
		protected function startTimer():void{
			m_objTimer.start();
		}
		public function startAll():void{
			startEnterFrame();
			startTimer();
		}
		public function stop(nRenderMethod:Number):void{
			if (nRenderMethod == RenderMethod.ENTER_FRAME){
				stopEnterFrame();
			} else {
				if (nRenderMethod == RenderMethod.TIMER){
					stopTimer();
				};
			};
		}
		protected function stopTimer():void{
			m_objTimer.stop();
		}
		public function stopAll():void{
			stopEnterFrame();
			stopTimer();
		}
		protected function startEnterFrame():void{
			if (!m_objStage){
				m_objStage = Global.stage;
			};
			if (m_objStage){
				m_objStage.addEventListener(Event.ENTER_FRAME, m_fncOnEnterFrame);
			} else {
				m_objLog.warning("startEnterFrame :: Unable to add a listener to the enter frame event because a global stage reference does not exist.");
			};
		}
		protected function stopEnterFrame():void{
			if (m_objStage){
				m_objStage.removeEventListener(Event.ENTER_FRAME, m_fncOnEnterFrame);
			};
		}
		public function dispose():void{
			if (((!((m_fncOnEnterFrame == null))) && (!((m_objStage == null))))){
				m_objStage.removeEventListener(Event.ENTER_FRAME, m_fncOnEnterFrame);
			};
			if (m_objTimer != null){
				m_objTimer.removeEventListener(TimerEvent.TIMER, m_fncOnTimer);
			};
			m_fncOnEnterFrame = null;
			m_objTimer = null;
			m_fncOnTimer = null;
			m_objStage = null;
		}

	}
}//package com.boostworthy.animation.rendering 
Section 109
//RenderMethod (com.boostworthy.animation.rendering.RenderMethod)
package com.boostworthy.animation.rendering {

	public final class RenderMethod {

		public static const TIMER:uint = 2;
		public static const ENTER_FRAME:uint = 1;

		public function RenderMethod(){
			super();
		}
	}
}//package com.boostworthy.animation.rendering 
Section 110
//BoostworthyAnimation (com.boostworthy.animation.BoostworthyAnimation)
package com.boostworthy.animation {
	import com.boostworthy.utils.logger.*;

	public final class BoostworthyAnimation {

		public static const VERSION:String = "2.1";
		public static const AUTHOR:String = "Copyright (c) 2007 Ryan Taylor | http://www.boostworthy.com";
		public static const NAME:String = "Boostworthy Animation System";
		public static const DATE:String = "06.07.2007";

		private static var c_bIsLogged:Boolean;

		public function BoostworthyAnimation(){
			super();
		}
		public static function log():void{
			if (!c_bIsLogged){
				LogFactory.getInstance().getLog(NAME).info(((("Version " + VERSION) + " :: ") + AUTHOR));
				c_bIsLogged = true;
			};
		}

	}
}//package com.boostworthy.animation 
Section 111
//ForwardArrayIterator (com.boostworthy.collections.iterators.ForwardArrayIterator)
package com.boostworthy.collections.iterators {

	public class ForwardArrayIterator implements IIterator {

		private var m_aData:Array;
		private var m_uIndex:uint;

		public function ForwardArrayIterator(aData:Array){
			super();
			m_aData = aData;
			reset();
		}
		public function reset():void{
			m_uIndex = 0;
		}
		public function next():Object{
			return (m_aData[m_uIndex++]);
		}
		public function hasNext():Boolean{
			return ((m_uIndex < m_aData.length));
		}

	}
}//package com.boostworthy.collections.iterators 
Section 112
//IIterator (com.boostworthy.collections.iterators.IIterator)
package com.boostworthy.collections.iterators {

	public interface IIterator {

		function next():Object;
		function hasNext():Boolean;
		function reset():void;

	}
}//package com.boostworthy.collections.iterators 
Section 113
//IteratorType (com.boostworthy.collections.iterators.IteratorType)
package com.boostworthy.collections.iterators {

	public final class IteratorType {

		public static const NULL:uint = 1;
		public static const ARRAY_REVERSE:uint = 4;
		public static const ARRAY_FORWARD:uint = 2;

		public function IteratorType(){
			super();
		}
	}
}//package com.boostworthy.collections.iterators 
Section 114
//ReverseArrayIterator (com.boostworthy.collections.iterators.ReverseArrayIterator)
package com.boostworthy.collections.iterators {

	public class ReverseArrayIterator implements IIterator {

		private var m_aData:Array;
		private var m_uIndex:uint;

		public function ReverseArrayIterator(aData:Array){
			super();
			m_aData = aData;
			reset();
		}
		public function reset():void{
			m_uIndex = m_aData.length;
		}
		public function next():Object{
			return (m_aData[--m_uIndex]);
		}
		public function hasNext():Boolean{
			return ((m_uIndex > 0));
		}

	}
}//package com.boostworthy.collections.iterators 
Section 115
//HashMap (com.boostworthy.collections.HashMap)
package com.boostworthy.collections {
	import com.boostworthy.core.*;
	import com.boostworthy.collections.iterators.*;

	public class HashMap implements ICollection, IDisposable {

		protected var m_aKeys:Array;
		protected var m_aValues:Array;

		public function HashMap(objMap:Object=null){
			super();
			init(objMap);
		}
		public function containsKey(objKey:Object):Boolean{
			return (!((searchForKey(objKey) == Global.NULL_INDEX)));
		}
		public function remove(objKey:Object):void{
			var iKeyIndex:int = searchForKey(objKey);
			if (iKeyIndex != Global.NULL_INDEX){
				m_aKeys.splice(iKeyIndex, 1);
				m_aValues.splice(iKeyIndex, 1);
			};
		}
		public function getValueIterator(uIterator:uint=2):IIterator{
			if (uIterator == IteratorType.ARRAY_FORWARD){
				return (new ForwardArrayIterator(m_aValues.concat()));
			};
			if (uIterator == IteratorType.ARRAY_REVERSE){
				return (new ReverseArrayIterator(m_aValues.concat()));
			};
			return (new ForwardArrayIterator(m_aValues.concat()));
		}
		public function getIterator(uIterator:uint=2):IIterator{
			return (getValueIterator(uIterator));
		}
		public function putMap(objMap:Object):void{
			var strKey:String;
			for (strKey in objMap) {
				put(strKey, objMap[strKey]);
			};
		}
		public function put(objKey:Object, objValue:Object):void{
			remove(objKey);
			m_aKeys.push(objKey);
			m_aValues.push(objValue);
		}
		protected function init(objMap:Object):void{
			dispose();
			if (objMap != null){
				putMap(objMap);
			};
		}
		public function get length():uint{
			return (m_aKeys.length);
		}
		public function get(objKey:Object):Object{
			var iKeyIndex:int = searchForKey(objKey);
			if (iKeyIndex != Global.NULL_INDEX){
				return (m_aValues[iKeyIndex]);
			};
			return (null);
		}
		public function getKeyIterator(uIterator:uint=2):IIterator{
			if (uIterator == IteratorType.ARRAY_FORWARD){
				return (new ForwardArrayIterator(m_aKeys.concat()));
			};
			if (uIterator == IteratorType.ARRAY_REVERSE){
				return (new ReverseArrayIterator(m_aKeys.concat()));
			};
			return (new ForwardArrayIterator(m_aKeys.concat()));
		}
		public function clone():HashMap{
			var objHashMap:HashMap = new HashMap();
			var nLength:int = m_aKeys.length;
			var i:int;
			while (i < nLength) {
				objHashMap.put(m_aKeys[i], m_aValues[i]);
				i++;
			};
			return (objHashMap);
		}
		protected function searchForKey(objKey:Object):int{
			var nLength:int = m_aKeys.length;
			var i:int;
			while (i < nLength) {
				if (m_aKeys[i] === objKey){
					return (i);
				};
				i++;
			};
			return (Global.NULL_INDEX);
		}
		public function dispose():void{
			m_aKeys = new Array();
			m_aValues = new Array();
		}

	}
}//package com.boostworthy.collections 
Section 116
//ICollection (com.boostworthy.collections.ICollection)
package com.boostworthy.collections {
	import com.boostworthy.collections.iterators.*;

	public interface ICollection {

		function getIterator(:uint=2):IIterator;

	}
}//package com.boostworthy.collections 
Section 117
//Queue (com.boostworthy.collections.Queue)
package com.boostworthy.collections {
	import com.boostworthy.core.*;
	import com.boostworthy.collections.iterators.*;

	public class Queue implements ICollection, IDisposable {

		protected var m_aData:Array;

		public function Queue(){
			super();
			dispose();
		}
		public function getIterator(uIterator:uint=2):IIterator{
			if (uIterator == IteratorType.ARRAY_FORWARD){
				return (new ForwardArrayIterator(m_aData.concat()));
			};
			if (uIterator == IteratorType.ARRAY_REVERSE){
				return (new ReverseArrayIterator(m_aData.concat()));
			};
			return (new ForwardArrayIterator(m_aData.concat()));
		}
		private function getElementIndex(objElement:Object):int{
			var i:int;
			while (i < m_aData.length) {
				if (m_aData[i] === objElement){
					return (i);
				};
				i++;
			};
			return (Global.NULL_INDEX);
		}
		public function get length():uint{
			return (m_aData.length);
		}
		public function removeElement(objElement:Object):void{
			var iIndex:int = getElementIndex(objElement);
			if (iIndex != Global.NULL_INDEX){
				m_aData.splice(iIndex, 1);
			};
		}
		public function addElement(objElement:Object):void{
			m_aData.push(objElement);
		}
		public function dispose():void{
			m_aData = new Array();
		}

	}
}//package com.boostworthy.collections 
Section 118
//EnhancedSprite (com.boostworthy.core.EnhancedSprite)
package com.boostworthy.core {
	import flash.events.*;
	import flash.display.*;
	import com.boostworthy.geom.*;
	import flash.filters.*;

	public class EnhancedSprite extends Sprite implements IColorable, IDisposable {

		protected var m_objColorMatrix:ColorMatrix;

		public function EnhancedSprite(){
			super();
			init();
		}
		protected function init():void{
			m_objColorMatrix = new ColorMatrix();
			m_objColorMatrix.addEventListener(Event.CHANGE, onColorMatrixChange);
		}
		protected function onColorMatrixChange(objEvent:Event):void{
			applyColorMatrix();
		}
		public function dispose():void{
			m_objColorMatrix.removeEventListener(Event.CHANGE, onColorMatrixChange);
			m_objColorMatrix = null;
			filters = new Array();
		}
		public function get colorMatrix():ColorMatrix{
			return (m_objColorMatrix);
		}
		protected function applyColorMatrix():void{
			var i:int;
			var aFilters:Array = new Array();
			var iLength:int = filters.length;
			if (iLength){
				i = 0;
				while (i < iLength) {
					if (!(filters[i] is ColorMatrixFilter)){
						aFilters.push(filters[i]);
					};
					i++;
				};
			};
			aFilters.push(new ColorMatrixFilter(m_objColorMatrix.valueOf()));
			filters = aFilters;
		}

	}
}//package com.boostworthy.core 
Section 119
//Global (com.boostworthy.core.Global)
package com.boostworthy.core {
	import flash.display.*;

	public final class Global {

		private static var c_objStage:Stage;
		public static var NULL_INDEX:int = -1;

		public function Global(){
			super();
			throw (new Error("ERROR -> Global :: Constructor :: The 'Global' class is not meant to be instantiated."));
		}
		public static function set stage(objStage:Stage):void{
			c_objStage = objStage;
		}
		public static function get stage():Stage{
			return (c_objStage);
		}

	}
}//package com.boostworthy.core 
Section 120
//IColorable (com.boostworthy.core.IColorable)
package com.boostworthy.core {
	import com.boostworthy.geom.*;

	public interface IColorable {

		function get colorMatrix():ColorMatrix;

	}
}//package com.boostworthy.core 
Section 121
//IDisposable (com.boostworthy.core.IDisposable)
package com.boostworthy.core {

	public interface IDisposable {

		function dispose():void;

	}
}//package com.boostworthy.core 
Section 122
//AnimationEvent (com.boostworthy.events.AnimationEvent)
package com.boostworthy.events {
	import flash.events.*;

	public class AnimationEvent extends Event {

		protected var m_strProperty:String;
		protected var m_objTarget:Object;

		public static const CHANGE:String = "animationChange";
		public static const STOP:String = "animationStop";
		public static const START:String = "animationStart";
		public static const FINISH:String = "animationFinish";

		public function AnimationEvent(strType:String, objTarget:Object=null, strProperty:String=""){
			super(strType);
			m_objTarget = objTarget;
			m_strProperty = strProperty;
		}
		public function get animTarget():Object{
			return (m_objTarget);
		}
		public function get animProperty():String{
			return (m_strProperty);
		}

	}
}//package com.boostworthy.events 
Section 123
//ColorMatrix (com.boostworthy.geom.ColorMatrix)
package com.boostworthy.geom {
	import flash.events.*;

	public class ColorMatrix extends EventDispatcher {

		protected const IDENTITY:Array;
		protected const LUMINANCE_B:Number = 0.072169;
		protected const LUMINANCE_G:Number = 0.71516;
		protected const LUMINANCE_R:Number = 0.212671;

		protected var m_nHue:Number;
		protected var m_nBrightness:Number;
		protected var m_nSaturation:Number;
		protected var m_nAlpha:Number;
		protected var m_aMatrix:Array;
		protected var m_nContrast:Number;

		public function ColorMatrix(aMatrix:Array=null){
			IDENTITY = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
			super();
			init(((aMatrix == null)) ? IDENTITY.concat() : aMatrix.concat());
		}
		protected function setDefaultValues():void{
			m_nAlpha = 100;
			m_nBrightness = 0;
			m_nContrast = 0;
			m_nHue = 0;
			m_nSaturation = 0;
		}
		public function get contrast():Number{
			return (m_nContrast);
		}
		protected function multiply(aMatrix:Array):void{
			var iRow:int;
			var aBuffer:Array = new Array();
			var iCount:int;
			var iCol:int;
			while (iCol < 4) {
				iRow = 0;
				while (iRow < 5) {
					aBuffer[(iCount + iRow)] = (((((aMatrix[iCount] * m_aMatrix[iRow]) + (aMatrix[(iCount + 1)] * m_aMatrix[(iRow + 5)])) + (aMatrix[(iCount + 2)] * m_aMatrix[(iRow + 10)])) + (aMatrix[(iCount + 3)] * m_aMatrix[(iRow + 15)])) + ((iRow == 4)) ? aMatrix[(iCount + 4)] : 0);
					iRow++;
				};
				iCount = (iCount + 5);
				iCol++;
			};
			m_aMatrix = aBuffer.concat();
			dispatchEvent(new Event(Event.CHANGE));
		}
		public function reset():void{
			init(IDENTITY.concat());
		}
		protected function init(aMatrix:Array):void{
			m_aMatrix = aMatrix;
			setDefaultValues();
		}
		public function get brightness():Number{
			return (m_nBrightness);
		}
		public function get saturation():Number{
			return (m_nSaturation);
		}
		public function set contrast(nContrast:Number):void{
			var nOldValue:Number = ((m_nContrast / 100) + 1);
			m_nContrast = nContrast;
			nContrast = ((nContrast / 100) + 1);
			nContrast = (nContrast / nOldValue);
			var aMatrix:Array = [nContrast, 0, 0, 0, (128 * (1 - nContrast)), 0, nContrast, 0, 0, (128 * (1 - nContrast)), 0, 0, nContrast, 0, (128 * (1 - nContrast)), 0, 0, 0, 1, 0];
			multiply(aMatrix);
		}
		public function set alpha(nAlpha:Number):void{
			var nOldValue:Number = (m_nAlpha / 100);
			m_nAlpha = nAlpha;
			nAlpha = (nAlpha / 100);
			nAlpha = (nAlpha / nOldValue);
			var aMatrix:Array = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, nAlpha, 0];
			multiply(aMatrix);
		}
		public function clone():ColorMatrix{
			return (new ColorMatrix(valueOf()));
		}
		public function get alpha():Number{
			return (m_nAlpha);
		}
		public function set saturation(nSaturation:Number):void{
			var nOldValue:Number = ((m_nSaturation + 100) / 100);
			m_nSaturation = Math.min(100, Math.max(-99.99, nSaturation));
			nSaturation = ((m_nSaturation + 100) / 100);
			nSaturation = (nSaturation / nOldValue);
			var nLumR:Number = ((1 - nSaturation) * LUMINANCE_R);
			var nLumG:Number = ((1 - nSaturation) * LUMINANCE_G);
			var nLumB:Number = ((1 - nSaturation) * LUMINANCE_B);
			var aMatrix:Array = [(nLumR + nSaturation), nLumG, nLumB, 0, 0, nLumR, (nLumG + nSaturation), nLumB, 0, 0, nLumR, nLumG, (nLumB + nSaturation), 0, 0, 0, 0, 0, 1, 0];
			multiply(aMatrix);
		}
		public function valueOf():Array{
			return (m_aMatrix.concat());
		}
		public function set brightness(nBrightness:Number):void{
			var nOldValue:Number = (m_nBrightness * (0xFF / 100));
			m_nBrightness = nBrightness;
			nBrightness = (nBrightness * (0xFF / 100));
			nBrightness = (nBrightness - nOldValue);
			var aMatrix:Array = [1, 0, 0, 0, nBrightness, 0, 1, 0, 0, nBrightness, 0, 0, 1, 0, nBrightness, 0, 0, 0, 1, 0];
			multiply(aMatrix);
		}
		public function set hue(nAngle:Number):void{
			var nOldValue:Number = (m_nHue * (Math.PI / 180));
			m_nHue = nAngle;
			nAngle = (nAngle * (Math.PI / 180));
			nAngle = (nAngle - nOldValue);
			var nCos:Number = Math.cos(nAngle);
			var nSin:Number = Math.sin(nAngle);
			var aMatrix:Array = [((LUMINANCE_R + (nCos * (1 - LUMINANCE_R))) + (nSin * -(LUMINANCE_R))), ((LUMINANCE_G + (nCos * -(LUMINANCE_G))) + (nSin * -(LUMINANCE_G))), ((LUMINANCE_B + (nCos * -(LUMINANCE_B))) + (nSin * (1 - LUMINANCE_B))), 0, 0, ((LUMINANCE_R + (nCos * -(LUMINANCE_R))) + (nSin * 0.143)), ((LUMINANCE_G + (nCos * (1 - LUMINANCE_G))) + (nSin * 0.14)), ((LUMINANCE_B + (nCos * -(LUMINANCE_B))) + (nSin * -0.283)), 0, 0, ((LUMINANCE_R + (nCos * -(LUMINANCE_R))) + (nSin * -((1 - LUMINANCE_R)))), ((LUMINANCE_G + (nCos * -(LUMINANCE_G))) + (nSin * LUMINANCE_G)), ((LUMINANCE_B + (nCos * (1 - LUMINANCE_B))) + (nSin * LUMINANCE_B)), 0, 0, 0, 0, 0, 1, 0];
			multiply(aMatrix);
		}
		public function get hue():Number{
			return (m_nHue);
		}

	}
}//package com.boostworthy.geom 
Section 124
//ILog (com.boostworthy.utils.logger.ILog)
package com.boostworthy.utils.logger {

	public interface ILog {

		function getName():String;
		function setLevel(com.boostworthy.utils.logger:ILog/com.boostworthy.utils.logger:ILog:getName:uint):void;
		function debug(com.boostworthy.utils.logger:ILog/com.boostworthy.utils.logger:ILog:getName:String):void;
		function severe(com.boostworthy.utils.logger:ILog/com.boostworthy.utils.logger:ILog:getName:String):void;
		function getLevel():uint;
		function warning(com.boostworthy.utils.logger:ILog/com.boostworthy.utils.logger:ILog:getName:String):void;
		function info(com.boostworthy.utils.logger:ILog/com.boostworthy.utils.logger:ILog:getName:String):void;

	}
}//package com.boostworthy.utils.logger 
Section 125
//Log (com.boostworthy.utils.logger.Log)
package com.boostworthy.utils.logger {

	public class Log implements ILog {

		protected var m_strName:String;
		protected var m_uLevel:uint;

		public function Log(strName:String, uLevel:uint){
			super();
			init(strName, uLevel);
		}
		protected function output(strMessage:String, uLevel:uint):void{
			if (((!((m_uLevel & LogLevel.OFF))) && ((m_uLevel >= uLevel)))){
				trace(createOutputMessage(strMessage, uLevel));
			};
		}
		public function getName():String{
			return (m_strName);
		}
		public function setLevel(uLevel:uint):void{
			m_uLevel = uLevel;
		}
		protected function createOutputMessage(strMessage:String, uLevel:uint):String{
			return ((((((m_strName + " (") + getLevelName(uLevel)) + ") :: ") + strMessage) + "\n"));
		}
		public function getLevel():uint{
			return (m_uLevel);
		}
		protected function init(strName:String, uLevel:uint):void{
			m_strName = strName;
			m_uLevel = uLevel;
		}
		protected function getLevelName(uLevel:uint):String{
			switch (uLevel){
				case LogLevel.OFF:
					return ("OFF");
				case LogLevel.SEVERE:
					return ("SEVERE");
				case LogLevel.WARNING:
					return ("WARNING");
				case LogLevel.INFO:
					return ("INFO");
				case LogLevel.DEBUG:
					return ("DEBUG");
				default:
					return ("");
			};
		}
		public function debug(strMessage:String):void{
			output(strMessage, LogLevel.DEBUG);
		}
		public function severe(strMessage:String):void{
			output(strMessage, LogLevel.SEVERE);
		}
		public function warning(strMessage:String):void{
			output(strMessage, LogLevel.WARNING);
		}
		public function info(strMessage:String):void{
			output(strMessage, LogLevel.INFO);
		}

	}
}//package com.boostworthy.utils.logger 
Section 126
//LogFactory (com.boostworthy.utils.logger.LogFactory)
package com.boostworthy.utils.logger {
	import com.boostworthy.core.*;
	import com.boostworthy.collections.iterators.*;
	import com.boostworthy.collections.*;

	public class LogFactory implements IDisposable {

		private var m_uLevel:uint;
		private var m_objLogHash:HashMap;

		private static var c_objInstance:LogFactory;

		public function LogFactory(objEnforcer:SingletonEnforcer){
			super();
			init();
		}
		protected function init():void{
			m_uLevel = LogSettings.DEFAULT_LOG_LEVEL;
			m_objLogHash = new HashMap();
		}
		public function getLog(strLogName:String):ILog{
			if (m_objLogHash.containsKey(strLogName)){
				return ((m_objLogHash.get(strLogName) as ILog));
			};
			m_objLogHash.put(strLogName, new Log(strLogName, m_uLevel));
			return ((m_objLogHash.get(strLogName) as ILog));
		}
		public function setLevel(uLevel:uint):void{
			m_uLevel = uLevel;
			var objIterator:IIterator = m_objLogHash.getValueIterator();
			while (objIterator.hasNext()) {
				objIterator.next().setLevel(m_uLevel);
			};
		}
		public function getLevel():uint{
			return (m_uLevel);
		}
		public function dispose():void{
			m_objLogHash.dispose();
		}

		public static function getInstance():LogFactory{
			if (c_objInstance == null){
				c_objInstance = new LogFactory(new SingletonEnforcer());
			};
			return (c_objInstance);
		}

	}
}//package com.boostworthy.utils.logger 

class SingletonEnforcer {

	private function SingletonEnforcer(){
		super();
	}
}
Section 127
//LogLevel (com.boostworthy.utils.logger.LogLevel)
package com.boostworthy.utils.logger {

	public final class LogLevel {

		public static const SEVERE:uint = 2;
		public static const INFO:uint = 8;
		public static const DEBUG:uint = 16;
		public static const WARNING:uint = 4;
		public static const OFF:uint = 1;

		public function LogLevel(){
			super();
		}
	}
}//package com.boostworthy.utils.logger 
Section 128
//LogSettings (com.boostworthy.utils.logger.LogSettings)
package com.boostworthy.utils.logger {

	public final class LogSettings {

		public static const DEFAULT_LOG_LEVEL:uint = LogLevel.DEBUG;

		public function LogSettings(){
			super();
		}
	}
}//package com.boostworthy.utils.logger 
Section 129
//SoundSkin (com.gmac.sound.SoundSkin)
package com.gmac.sound {
	import flash.events.*;
	import flash.media.*;
	import flash.net.*;

	public class SoundSkin extends EventDispatcher {

		private var _channel:SoundChannel;
		private var _loopCount:int;// = 0
		private var _sound:Sound;
		public var loops:int;// = 1
		private var _pan:Number;// = 0
		private var _autoPlay:Boolean;// = false
		private var _loaded:Boolean;// = false
		private var _playhead:Number;// = 0
		private var _mute:Boolean;// = false
		private var _volume:Number;// = 1

		public function SoundSkin($sound:Sound=null, $loops:int=1, $startTime:Number=0):void{
			super();
			_sound = (($sound is Sound)) ? $sound : new Sound();
			_loaded = !(($sound == null));
			_playhead = $startTime;
			loops = $loops;
		}
		public function get percentPlayback():Number{
			var $percent:Number = (playing) ? (_channel.position / estimatedLength) : (_playhead / estimatedLength);
			return ((isNaN($percent)) ? 0 : $percent);
		}
		public function set mute($mute:Boolean):void{
			_mute = $mute;
			if (playing){
				_channel.soundTransform = _getTransform();
			};
		}
		public function play():void{
			if (((!(playing)) && ((percentLoaded > 0)))){
				_channel = _sound.play(_playhead, 0, _getTransform());
				if (_channel != null){
					_channel.addEventListener(Event.SOUND_COMPLETE, this._onSoundComplete, false, 0, true);
				};
			};
		}
		public function get loaded():Boolean{
			return (_loaded);
		}
		public function set percentPlayback($percent:Number):void{
			position = (estimatedLength * $percent);
		}
		public function get estimatedLength():Number{
			var $length:Number = (loaded) ? _sound.length : (_sound.length / percentLoaded);
			return ((isNaN($length)) ? 0 : $length);
		}
		private function _onSoundComplete($event:Event):void{
			_channel.removeEventListener(Event.SOUND_COMPLETE, this._onSoundComplete);
			_channel = null;
			_loopCount++;
			if ((((loops <= 0)) || ((_loopCount < loops)))){
				rewind();
				play();
				dispatchEvent(new SoundSkinEvent(SoundSkinEvent.SOUND_LOOP));
			} else {
				reset();
				dispatchEvent(new SoundSkinEvent(SoundSkinEvent.SOUND_COMPLETE));
			};
		}
		public function toggleMute():void{
			mute = !(_mute);
		}
		public function stop():void{
			if (playing){
				_playhead = _channel.position;
				_channel.stop();
				_channel.removeEventListener(Event.SOUND_COMPLETE, this._onSoundComplete);
				_channel = null;
			};
		}
		public function set position($milliseconds:Number):void{
			var $resume:Boolean = playing;
			stop();
			_playhead = Math.max(0, Math.min($milliseconds, _sound.length));
			if ($resume){
				play();
			};
		}
		private function _getTransform():SoundTransform{
			return (new SoundTransform((_mute) ? 0 : _volume, _pan));
		}
		public function get mute():Boolean{
			return (_mute);
		}
		public function get volume():Number{
			return (_volume);
		}
		public function set pan($value:Number):void{
			_pan = Math.max(-1, Math.min($value, 1));
			if (playing){
				_channel.soundTransform = _getTransform();
			};
		}
		public function get pan():Number{
			return (_pan);
		}
		public function togglePlayback():void{
			if (playing){
				stop();
			} else {
				play();
			};
		}
		public function get sound():Sound{
			return (_sound);
		}
		public function get position():Number{
			if (playing){
				return (_channel.position);
			};
			return (_playhead);
		}
		public function get percentLoaded():Number{
			var $percent:Number = (_sound.bytesLoaded / _sound.bytesTotal);
			return ((isNaN($percent)) ? 0 : $percent);
		}
		private function _onLoadComplete($event:Event):void{
			_sound.removeEventListener(Event.COMPLETE, this._onLoadComplete);
			_loaded = true;
			dispatchEvent(new SoundSkinEvent(SoundSkinEvent.SOUND_LOADED));
		}
		public function load($url:String, $autoPlay:Boolean=false, $bufferSeconds:Number=1):void{
			if ((((_sound.url == null)) && ((percentLoaded == 0)))){
				_autoPlay = $autoPlay;
				_sound.addEventListener(ProgressEvent.PROGRESS, this._onLoadProgress, false, 0, true);
				_sound.addEventListener(Event.COMPLETE, this._onLoadComplete, false, 0, true);
				_sound.load(new URLRequest($url), new SoundLoaderContext(($bufferSeconds * 1000)));
			};
		}
		public function get playing():Boolean{
			return (!((_channel == null)));
		}
		public function reset():void{
			_loopCount = 0;
			rewind();
		}
		public function set volume($volume:Number):void{
			_volume = $volume;
			if (playing){
				_channel.soundTransform = _getTransform();
			};
		}
		public function get length():Number{
			return (_sound.length);
		}
		public function destroy():void{
			stop();
			if (((!((_sound.url == null))) && (!(_loaded)))){
				_sound.close();
			};
			_sound = null;
			_channel = null;
		}
		public function rewind():void{
			if (playing){
				stop();
				_playhead = 0;
				play();
			} else {
				_playhead = 0;
			};
		}
		private function _onLoadProgress($event:ProgressEvent):void{
			if (((_autoPlay) && ((percentLoaded > 0)))){
				play();
			};
			if (playing){
				_sound.removeEventListener(ProgressEvent.PROGRESS, this._onLoadProgress);
			};
		}

	}
}//package com.gmac.sound 
Section 130
//SoundSkinEvent (com.gmac.sound.SoundSkinEvent)
package com.gmac.sound {
	import flash.events.*;

	public class SoundSkinEvent extends Event {

		public static const SOUND_LOOP:String = "soundSkinLoop";
		public static const SOUND_LOADED:String = "soundSkinLoaded";
		public static const SOUND_COMPLETE:String = "soundSkinComplete";
		public static const SOUND_FADE:String = "soundSkinFade";

		public function SoundSkinEvent($type:String):void{
			super($type, false, false);
		}
	}
}//package com.gmac.sound 
Section 131
//Plane (com.parallax.objects.Plane)
package com.parallax.objects {
	import flash.display.*;

	public class Plane extends Sprite {

		public var container:Sprite;
		private var _zPos:Number;
		private var _yPos:Number;
		private var _xPos:Number;
		private var _object:DisplayObject;

		public function Plane():void{
			super();
			container = new Sprite();
			addChild(container);
		}
		public function get xPos():Number{
			return (_xPos);
		}
		public function set object(obj:DisplayObject):void{
			container.addChildAt(obj, 0);
			_object = obj;
		}
		public function get zPos():Number{
			return (_zPos);
		}
		public function get yPos():Number{
			return (_yPos);
		}
		public function set zPos(value:Number):void{
			_zPos = value;
			if (_zPos == 0){
				_zPos = 1;
			};
		}
		public function init():void{
		}
		public function set xPos(value:Number):void{
			container.x = value;
			_xPos = value;
		}
		public function set yPos(value:Number):void{
			container.y = value;
			_yPos = value;
		}
		public function get object():DisplayObject{
			return (_object);
		}

	}
}//package com.parallax.objects 
Section 132
//Parallax (com.parallax.Parallax)
package com.parallax {
	import flash.display.*;
	import flash.geom.*;
	import com.boostworthy.core.*;
	import com.parallax.objects.*;

	public class Parallax extends EnhancedSprite {

		private var thisStage;
		public var container:EnhancedSprite;
		private var locked:Boolean;// = false
		public var thresholdX:Number;// = 100
		public var thresholdY:Number;// = 10
		private var positionX:int;// = 0
		private var positionY:int;// = 0
		public var borders:Object;
		public var planes:Object;
		public var speed:Point;
		private var position;
		private var focalPoint:Point;
		public var ease:Number;// = 0.5

		private static var planeDistance:uint = 50;

		public function Parallax(mstage):void{
			focalPoint = new Point(0, 0);
			speed = new Point(30, 30);
			super();
			thisStage = mstage;
			planes = new Array();
			container = new EnhancedSprite();
			borders = {x1:0, y1:0, x2:0, y2:0};
		}
		public function unlock():void{
			locked = false;
		}
		public function update(focus:Point, px=100, py=250):void{
			var i:uint;
			if (planes.length > 1){
				planes[(planes.length - 1)].x = -((focus.x - px));
				planes[(planes.length - 1)].y = -((focus.y - py));
				i = 0;
				while (i < (planes.length - 1)) {
					planes[i].x = -(((focus.x * planeDistance) / planes[i].zPos));
					planes[i].y = -(((focus.y * planeDistance) / planes[i].zPos));
					i++;
				};
			};
		}
		public function pinit():void{
			addChild(container);
			var i:uint;
			while (i < planes.length) {
				planes[i].x = (0 - ((position * planeDistance) / planes[i].zPos));
				i++;
			};
		}
		public function lock(x:Number=0, y:Number=0):void{
			positionX = x;
			positionY = y;
			locked = true;
		}
		public function removeAllPlanes():void{
			var item:*;
			for each (item in planes) {
				item.visible = false;
				container.removeChild(item);
				item = null;
			};
			planes = new Array();
		}
		public function removePlane(plane:Plane):void{
			var i:uint;
			while (i < planes.length) {
				if (planes[i] == plane){
					planes.splice(i, 1);
					break;
				};
				i++;
			};
			plane.visible = false;
			container.removeChild(plane);
			plane = null;
		}
		public function addPlane(object:DisplayObject, x:Number=0, y:Number=0, z:Number=0, static:Boolean=false):Plane{
			var plane:Plane = new Plane();
			plane.object = object;
			plane.xPos = x;
			plane.yPos = y;
			plane.zPos = z;
			container.addChild(plane);
			if (static != true){
				planes.push(plane);
			};
			return (plane);
		}

	}
}//package com.parallax 
Section 133
//GenericEmitter (com.roguedevelopment.pulse.emitter.GenericEmitter)
package com.roguedevelopment.pulse.emitter {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;
	import com.roguedevelopment.pulse.particle.*;
	import com.roguedevelopment.pulse.*;

	public class GenericEmitter implements IParticleEmitter {

		protected var _y:Number;// = 10
		protected var timer:Timer;
		public var width:Number;// = 1
		public var newParticlesOnTop:Boolean;// = true
		protected var factory:IParticleFactory;
		public var particleLimit:uint;// = 0
		public var root:DisplayObjectContainer;// = null
		public var height:Number;// = 1
		protected var particleCount:uint;// = 0
		protected var _x:Number;// = 10

		public function GenericEmitter(particlesPerSecond:Number){
			super();
			pps = particlesPerSecond;
			root = PulseEngine.instance.root;
		}
		public function get y():Number{
			return (_y);
		}
		public function stop():void{
			if (factory != null){
				factory.cleanup();
			};
			timer.stop();
		}
		public function setFactory(factory:IParticleFactory):void{
			this.factory = factory;
		}
		protected function emit(event:TimerEvent):void{
			if (factory == null){
				return;
			};
			if (particleLimit > 0){
				particleCount++;
				if (particleCount > particleLimit){
					timer.stop();
					return;
				};
			};
			var particle:IParticle = factory.newParticle();
			particle.x = (x + (Math.random() * width));
			particle.y = (y + (Math.random() * height));
			if ((particle is DisplayObject)){
				if (newParticlesOnTop){
					root.addChild((particle as DisplayObject));
				} else {
					root.addChildAt((particle as DisplayObject), 0);
				};
			};
			PulseEngine.instance.addParticle(particle);
		}
		public function getFactory():IParticleFactory{
			return (factory);
		}
		public function set y(v:Number):void{
			_y = v;
		}
		public function set pps(val:Number):void{
			if (timer != null){
				timer.stop();
			};
			timer = new Timer((1000 / val));
			timer.addEventListener(TimerEvent.TIMER, emit);
			timer.start();
		}
		public function set x(v:Number):void{
			_x = v;
		}
		public function start():void{
			particleCount = 0;
			timer.start();
		}
		public function get pps():Number{
			return (10);
		}
		public function get x():Number{
			return (_x);
		}

	}
}//package com.roguedevelopment.pulse.emitter 
Section 134
//IParticleEmitter (com.roguedevelopment.pulse.emitter.IParticleEmitter)
package com.roguedevelopment.pulse.emitter {
	import com.roguedevelopment.pulse.particle.*;

	public interface IParticleEmitter {

		function set x(:Number):void;
		function stop():void;
		function set y(:Number):void;
		function get x():Number;
		function get y():Number;
		function start():void;
		function setFactory(:IParticleFactory):void;

	}
}//package com.roguedevelopment.pulse.emitter 
Section 135
//AngleRandomizerInitializer (com.roguedevelopment.pulse.initializers.AngleRandomizerInitializer)
package com.roguedevelopment.pulse.initializers {

	public class AngleRandomizerInitializer extends ParameterRandomizerInitializer {

		public function AngleRandomizerInitializer(minValue:Number, maxValue:Number){
			super("angle", ((minValue * Math.PI) / 180), ((maxValue * Math.PI) / 180), round);
		}
	}
}//package com.roguedevelopment.pulse.initializers 
Section 136
//IPulseInitializer (com.roguedevelopment.pulse.initializers.IPulseInitializer)
package com.roguedevelopment.pulse.initializers {
	import com.roguedevelopment.pulse.particle.*;

	public interface IPulseInitializer {

		function init(:IParticle):void;

	}
}//package com.roguedevelopment.pulse.initializers 
Section 137
//ParameterRandomizerInitializer (com.roguedevelopment.pulse.initializers.ParameterRandomizerInitializer)
package com.roguedevelopment.pulse.initializers {
	import com.roguedevelopment.pulse.particle.*;

	public class ParameterRandomizerInitializer implements IPulseInitializer {

		protected var propName:String;
		protected var round:Boolean;
		protected var maxValue:Number;
		protected var minValue:Number;

		public function ParameterRandomizerInitializer(propName:String, minValue:Number, maxValue:Number, round:Boolean=false){
			super();
			this.minValue = minValue;
			this.maxValue = maxValue;
			this.propName = propName;
			this.round = round;
		}
		public function init(particle:IParticle):void{
			var o:Object = particle;
			var v:Number = (minValue + (Math.random() * (maxValue - minValue)));
			if (round){
				v = Math.round(v);
			};
			if (o.hasOwnProperty(propName)){
				o[propName] = v;
			} else {
				if (o.hasOwnProperty("params")){
					o.params[propName] = v;
				};
			};
		}

	}
}//package com.roguedevelopment.pulse.initializers 
Section 138
//DotBloodParticle (com.roguedevelopment.pulse.particle.DotBloodParticle)
package com.roguedevelopment.pulse.particle {

	public class DotBloodParticle extends GenericParticle {

		private var bloodSkinClass:Class;

		public function DotBloodParticle(){
			bloodSkinClass = DotBloodParticle_bloodSkinClass;
			super();
			redraw();
		}
		protected function redraw():void{
			var blood:* = new bloodSkinClass();
			this.addChild(blood);
		}

	}
}//package com.roguedevelopment.pulse.particle 
Section 139
//DotBloodParticle_bloodSkinClass (com.roguedevelopment.pulse.particle.DotBloodParticle_bloodSkinClass)
package com.roguedevelopment.pulse.particle {
	import flash.display.*;
	import mx.core.*;

	public class DotBloodParticle_bloodSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package com.roguedevelopment.pulse.particle 
Section 140
//DotExplodeParticle (com.roguedevelopment.pulse.particle.DotExplodeParticle)
package com.roguedevelopment.pulse.particle {

	public class DotExplodeParticle extends GenericParticle {

		private var ExplodSkinClass:Class;

		public function DotExplodeParticle(){
			ExplodSkinClass = DotExplodeParticle_ExplodSkinClass;
			super();
			redraw();
		}
		protected function redraw():void{
			var explod:* = new ExplodSkinClass();
			this.addChild(explod);
		}

	}
}//package com.roguedevelopment.pulse.particle 
Section 141
//DotExplodeParticle_ExplodSkinClass (com.roguedevelopment.pulse.particle.DotExplodeParticle_ExplodSkinClass)
package com.roguedevelopment.pulse.particle {
	import flash.display.*;
	import mx.core.*;

	public class DotExplodeParticle_ExplodSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package com.roguedevelopment.pulse.particle 
Section 142
//DotSmokeParticle (com.roguedevelopment.pulse.particle.DotSmokeParticle)
package com.roguedevelopment.pulse.particle {

	public class DotSmokeParticle extends GenericParticle {

		private var smokeSkinClass:Class;

		public function DotSmokeParticle(){
			smokeSkinClass = DotSmokeParticle_smokeSkinClass;
			super();
			redraw();
		}
		protected function redraw():void{
			var smoke:* = new smokeSkinClass();
			this.addChild(smoke);
		}

	}
}//package com.roguedevelopment.pulse.particle 
Section 143
//DotSmokeParticle_smokeSkinClass (com.roguedevelopment.pulse.particle.DotSmokeParticle_smokeSkinClass)
package com.roguedevelopment.pulse.particle {
	import flash.display.*;
	import mx.core.*;

	public class DotSmokeParticle_smokeSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package com.roguedevelopment.pulse.particle 
Section 144
//DotSparkParticle (com.roguedevelopment.pulse.particle.DotSparkParticle)
package com.roguedevelopment.pulse.particle {
	import flash.display.*;
	import flash.filters.*;

	public class DotSparkParticle extends GenericParticle {

		protected var _size:Number;// = 1
		protected var _color:uint;// = 0xFFF000

		public function DotSparkParticle(){
			super();
			redraw();
		}
		public function set size(s:Number):void{
			_size = s;
			redraw();
		}
		public function set color(c:uint):void{
			_color = c;
			redraw();
		}
		protected function redraw():void{
			var spark:* = new MovieClip();
			this.addChild(spark);
			spark.graphics.clear();
			spark.graphics.beginFill(_color, 0.5);
			spark.graphics.drawCircle(0, 0, _size);
			spark.graphics.endFill();
			var filter2:GlowFilter = new GlowFilter(0xFFF000, 1, 2, 2, 10, 1);
		}

	}
}//package com.roguedevelopment.pulse.particle 
Section 145
//GenericFactory (com.roguedevelopment.pulse.particle.GenericFactory)
package com.roguedevelopment.pulse.particle {
	import flash.display.*;
	import com.roguedevelopment.pulse.initializers.*;

	public final class GenericFactory implements IParticleFactory {

		protected var partClass:Class;
		protected var _initializers:Array;
		protected var recycled:Array;
		public var isRunning:Boolean;// = true
		protected var _rules:Array;

		public function GenericFactory(particleClass:Class, rules:Array, initializers:Array){
			recycled = [];
			super();
			this.partClass = particleClass;
			_rules = rules;
			this.initializers = initializers;
		}
		public function cleanup():void{
			var p:IParticle;
			isRunning = false;
			for each (p in recycled) {
				p.remove();
			};
			recycled = [];
		}
		public function newParticle():IParticle{
			var particle:IParticle;
			var initRule:IPulseInitializer;
			var obj:Object;
			isRunning = true;
			if (recycled.length > 0){
				particle = (recycled.shift() as IParticle);
				(particle as IRecyleableParticle).recycle();
			} else {
				obj = new partClass();
				if ((obj is IParticle)){
					particle = (obj as IParticle);
				} else {
					if ((obj is Sprite)){
						particle = new GenericParticle();
						(particle as GenericParticle).addChild((obj as Sprite));
					};
				};
				if ((particle is IRecyleableParticle)){
					(particle as IRecyleableParticle).factory = this;
				};
			};
			particle.rules = _rules.concat();
			for each (initRule in _initializers) {
				trace(initRule);
				initRule.init(particle);
			};
			return (particle);
		}
		public function set initializers(rules:Array):void{
			_initializers = rules;
		}
		public function recycle(particle:IParticle):void{
			if (isRunning){
				particle.visible = false;
				recycled.push(particle);
			} else {
				particle.remove();
			};
		}
		public function set rules(rules:Array):void{
			_rules = rules;
		}

	}
}//package com.roguedevelopment.pulse.particle 
Section 146
//GenericParticle (com.roguedevelopment.pulse.particle.GenericParticle)
package com.roguedevelopment.pulse.particle {
	import flash.display.*;
	import flash.geom.*;

	public class GenericParticle extends Sprite implements IRecyleableParticle {

		protected var _birth:Number;
		protected var _factory:IParticleFactory;
		protected var _params:Object;
		protected var _rules:Array;

		public function GenericParticle(){
			_params = {angle:0, speed:0};
			super();
			_birth = new Date().time;
		}
		public function remove():void{
			if (parent != null){
				parent.removeChild(this);
			};
		}
		public function get params():Object{
			return (_params);
		}
		public function get factory():IParticleFactory{
			return (_factory);
		}
		public function recycle():void{
			_birth = new Date().time;
			scaleX = 1;
			rotation = 0;
			scaleY = 1;
			alpha = 1;
			visible = true;
			transform.colorTransform = new ColorTransform();
		}
		public function set factory(v:IParticleFactory):void{
			_factory = v;
		}
		public function get rules():Array{
			return (_rules);
		}
		public function get birthTime():Number{
			return (_birth);
		}
		public function set rules(rules:Array):void{
			_rules = rules;
		}

	}
}//package com.roguedevelopment.pulse.particle 
Section 147
//IParticle (com.roguedevelopment.pulse.particle.IParticle)
package com.roguedevelopment.pulse.particle {

	public interface IParticle {

		function get visible():Boolean;
		function set alpha(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Number):void;
		function set visible(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Boolean):void;
		function get alpha():Number;
		function get params():Object;
		function set rotation(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Number):void;
		function get birthTime():Number;
		function get rotation():Number;
		function set rules(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Array):void;
		function get scaleY():Number;
		function set x(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Number):void;
		function set y(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Number):void;
		function remove():void;
		function get scaleX():Number;
		function get rules():Array;
		function get x():Number;
		function get y():Number;
		function set scaleX(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Number):void;
		function set scaleY(com.roguedevelopment.pulse.particle:IParticle/com.roguedevelopment.pulse.particle:IParticle:params/get:Number):void;

	}
}//package com.roguedevelopment.pulse.particle 
Section 148
//IParticleFactory (com.roguedevelopment.pulse.particle.IParticleFactory)
package com.roguedevelopment.pulse.particle {

	public interface IParticleFactory {

		function set initializers(E:\lab\flex\box2dFlash\source;com\roguedevelopment\pulse\particle;IParticleFactory.as:Array):void;
		function cleanup():void;
		function newParticle():IParticle;
		function recycle(E:\lab\flex\box2dFlash\source;com\roguedevelopment\pulse\particle;IParticleFactory.as:IParticle):void;
		function set rules(E:\lab\flex\box2dFlash\source;com\roguedevelopment\pulse\particle;IParticleFactory.as:Array):void;

	}
}//package com.roguedevelopment.pulse.particle 
Section 149
//IRecyleableParticle (com.roguedevelopment.pulse.particle.IRecyleableParticle)
package com.roguedevelopment.pulse.particle {

	public interface IRecyleableParticle extends IParticle {

		function get factory():IParticleFactory;
		function recycle():void;
		function set factory(E:\lab\flex\box2dFlash\source;com\roguedevelopment\pulse\particle;IRecyleableParticle.as:IParticleFactory):void;

	}
}//package com.roguedevelopment.pulse.particle 
Section 150
//DeathRule (com.roguedevelopment.pulse.rule.DeathRule)
package com.roguedevelopment.pulse.rule {
	import com.roguedevelopment.pulse.particle.*;
	import com.roguedevelopment.pulse.*;

	public final class DeathRule implements IPulseRule {

		protected var maxAge:Number;

		public function DeathRule(maxAge:Number=3000){
			super();
			this.maxAge = maxAge;
		}
		public function configure(params:Array):void{
			maxAge = (params[0] as Number);
		}
		public function applyRule(pulse:IParticle, currentMs:Number, lastMs:Number):void{
			if (currentMs > (maxAge + pulse.birthTime)){
				PulseEngine.instance.removeParticle(pulse);
				pulse.rules.splice(pulse.rules.indexOf(this), 1);
			};
		}

	}
}//package com.roguedevelopment.pulse.rule 
Section 151
//FadeRule (com.roguedevelopment.pulse.rule.FadeRule)
package com.roguedevelopment.pulse.rule {
	import com.roguedevelopment.pulse.particle.*;

	public final class FadeRule implements IPulseRule {

		protected var maxAge:Number;

		public function FadeRule(maxAge:Number=3000){
			super();
			this.maxAge = maxAge;
		}
		public function configure(params:Array):void{
			maxAge = (params[0] as Number);
		}
		public function applyRule(pulse:IParticle, currentMs:Number, lastMs:Number):void{
			if (currentMs == pulse.birthTime){
				return;
			};
			var age:Number = (currentMs - pulse.birthTime);
			if (age > maxAge){
				pulse.rules.splice(pulse.rules.indexOf(this), 1);
				return;
			};
			pulse.alpha = (1 - (age / maxAge));
		}

	}
}//package com.roguedevelopment.pulse.rule 
Section 152
//GravityRule (com.roguedevelopment.pulse.rule.GravityRule)
package com.roguedevelopment.pulse.rule {
	import com.roguedevelopment.pulse.particle.*;

	public final class GravityRule implements IPulseRule {

		protected var gravityAmount:Number;

		public function GravityRule(gravityAmount:Number=5){
			super();
			this.gravityAmount = gravityAmount;
		}
		public function applyRule(pulse:IParticle, currentMs:Number, lastMs:Number):void{
			var s:Number = pulse.params.speed;
			var a:Number = pulse.params.angle;
			var dx:Number = (Math.cos(a) * s);
			var dy:Number = ((Math.sin(a) * s) + gravityAmount);
			a = Math.atan2(dy, dx);
			if (a < 0){
				a = (a + (2 * Math.PI));
			};
			if (a > (2 * Math.PI)){
				a = (a - (2 * Math.PI));
			};
			pulse.params.angle = a;
			pulse.params.speed = Math.sqrt(((dx * dx) + (dy * dy)));
		}
		public function configure(params:Array):void{
			gravityAmount = (params[0] as Number);
		}

	}
}//package com.roguedevelopment.pulse.rule 
Section 153
//IPulseRule (com.roguedevelopment.pulse.rule.IPulseRule)
package com.roguedevelopment.pulse.rule {
	import com.roguedevelopment.pulse.particle.*;

	public interface IPulseRule {

		function applyRule(_arg1:IParticle, _arg2:Number, _arg3:Number):void;
		function configure(:Array):void;

	}
}//package com.roguedevelopment.pulse.rule 
Section 154
//MovementRule (com.roguedevelopment.pulse.rule.MovementRule)
package com.roguedevelopment.pulse.rule {
	import com.roguedevelopment.pulse.particle.*;
	import com.roguedevelopment.pulse.*;

	public final class MovementRule implements IPulseRule {

		public function MovementRule(){
			super();
		}
		public function applyRule(pulse:IParticle, currentMs:Number, lastMs:Number):void{
			var speed:Number = 1;
			var angle:Number = 0;
			if (pulse.params.hasOwnProperty("speed")){
				speed = pulse.params["speed"];
			};
			if (pulse.params.hasOwnProperty("angle")){
				angle = pulse.params["angle"];
			};
			var desiredDistance:Number = ((PulseEngine.PARTICLE_LOOP_TIME / 1000) * speed);
			var dx:Number = (Math.cos(angle) * desiredDistance);
			var dy:Number = (Math.sin(angle) * desiredDistance);
			pulse.x = (pulse.x + dx);
			pulse.y = (pulse.y + dy);
		}
		public function configure(params:Array):void{
		}

	}
}//package com.roguedevelopment.pulse.rule 
Section 155
//ScaleRule (com.roguedevelopment.pulse.rule.ScaleRule)
package com.roguedevelopment.pulse.rule {
	import com.roguedevelopment.pulse.particle.*;
	import com.roguedevelopment.*;

	public final class ScaleRule implements IPulseRule {

		protected var startScale:Number;
		protected var targetScale:Number;
		protected var maxAge:Number;

		public function ScaleRule(maxAge:Number=3000, startScale:Number=1, targetScale:Number=5){
			super();
			this.maxAge = maxAge;
			this.targetScale = targetScale;
			this.startScale = startScale;
		}
		public function applyRule(pulse:IParticle, currentMs:Number, lastMs:Number):void{
			var age:Number = (currentMs - pulse.birthTime);
			if (age > maxAge){
				pulse.rules.splice(pulse.rules.indexOf(this), 1);
				return;
			};
			if (startScale > targetScale){
				pulse.scaleX = (startScale - PennerEasing.sineEaseInOut(age, targetScale, startScale, maxAge));
			} else {
				pulse.scaleX = PennerEasing.sineEaseInOut(age, startScale, targetScale, maxAge);
			};
			pulse.scaleY = pulse.scaleX;
		}
		public function configure(params:Array):void{
			maxAge = (params[0] as Number);
			startScale = (params[1] as Number);
			targetScale = (params[2] as Number);
		}

	}
}//package com.roguedevelopment.pulse.rule 
Section 156
//PulseEngine (com.roguedevelopment.pulse.PulseEngine)
package com.roguedevelopment.pulse {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;
	import com.roguedevelopment.pulse.particle.*;
	import com.roguedevelopment.pulse.rule.*;

	public final class PulseEngine {

		public var root:DisplayObjectContainer;
		protected var emitters:Array;
		protected var timer:Timer;
		protected var particles:Array;
		public var updateAfterTimer:Boolean;// = false
		protected var lastUpdate:Number;

		public static const PARTICLE_LOOP_TIME:Number = 30;

		protected static var _instance:PulseEngine;

		public function PulseEngine(){
			emitters = [];
			particles = [];
			super();
			if (_instance != null){
				throw (new Error("only one engine allowed"));
			};
			timer = new Timer(PARTICLE_LOOP_TIME);
			timer.addEventListener(TimerEvent.TIMER, onTime);
			timer.start();
			lastUpdate = new Date().time;
		}
		public function addParticle(particle:IParticle):void{
			particle.visible = false;
			particles.push(particle);
		}
		public function addEmitter(emitter:IParticleFactory):void{
			emitters.push(emitter);
		}
		public function removeParticle(particle:IParticle):void{
			particles.splice(particles.indexOf(particle), 1);
			if ((particle is IRecyleableParticle)){
				(particle as IRecyleableParticle).factory.recycle(particle);
			} else {
				particle.remove();
			};
		}
		protected function onTime(event:TimerEvent):void{
			var particle:IParticle;
			var rule:IPulseRule;
			var now:Date = new Date();
			for each (particle in particles) {
				particle.visible = true;
				for each (rule in particle.rules) {
					rule.applyRule(particle, now.time, lastUpdate);
				};
			};
			lastUpdate = now.time;
			if (updateAfterTimer){
				event.updateAfterEvent();
			};
		}
		public function stopAndRemoveAllParticles():void{
			var particle:IParticle;
			for each (particle in particles) {
				particle.remove();
			};
			particles = [];
		}

		public static function get instance():PulseEngine{
			if (_instance == null){
				_instance = new (PulseEngine);
			};
			return (_instance);
		}

	}
}//package com.roguedevelopment.pulse 
Section 157
//PennerEasing (com.roguedevelopment.PennerEasing)
package com.roguedevelopment {

	public class PennerEasing {

		public function PennerEasing(){
			super();
		}
		public static function quartEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((-(c) * ((((t * t) * t) * t) - 1)) + b));
		}
		public static function circEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return ((((-(c) / 2) * (Math.sqrt((1 - (t * t))) - 1)) + b));
			};
			t = (t - 2);
			return ((((c / 2) * (Math.sqrt((1 - (t * t))) + 1)) + b));
		}
		public static function expoEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			return (((t)==0) ? b : ((c * Math.pow(2, (10 * ((t / d) - 1)))) + b));
		}
		public static function elasticEaseInOut(t:Number, b:Number, c:Number, d:Number, a:Number, p:Number):Number{
			var s:Number;
			if (t == 0){
				return (b);
			};
			t = (t / (d / 2));
			if (t == 2){
				return ((b + c));
			};
			if (!p){
				p = (d * (0.3 * 1.5));
			};
			if (((!(a)) || ((a < Math.abs(c))))){
				a = c;
				s = (p / 4);
			} else {
				s = ((p / (2 * Math.PI)) * Math.asin((c / a)));
			};
			if (t < 1){
				--t;
				return (((-0.5 * ((a * Math.pow(2, (10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p)))) + b));
			};
			--t;
			return ((((((a * Math.pow(2, (-10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p))) * 0.5) + c) + b));
		}
		public static function expoEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			if (t == 0){
				return (b);
			};
			if (t == d){
				return ((b + c));
			};
			t = (t / (d / 2));
			if (t < 1){
				return ((((c / 2) * Math.pow(2, (10 * (t - 1)))) + b));
			};
			--t;
			return ((((c / 2) * (-(Math.pow(2, (-10 * t))) + 2)) + b));
		}
		public static function linearEaseNone(t:Number, b:Number, c:Number, d:Number):Number{
			return ((((c * t) / d) + b));
		}
		public static function sineEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			return ((((-(c) / 2) * (Math.cos(((Math.PI * t) / d)) - 1)) + b));
		}
		public static function quintEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return ((((((((c / 2) * t) * t) * t) * t) * t) + b));
			};
			t = (t - 2);
			return ((((c / 2) * (((((t * t) * t) * t) * t) + 2)) + b));
		}
		public static function quartEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return ((((((c * t) * t) * t) * t) + b));
		}
		public static function quadEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return (((((c / 2) * t) * t) + b));
			};
			--t;
			return ((((-(c) / 2) * ((t * (t - 2)) - 1)) + b));
		}
		public static function cubicEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((c * (((t * t) * t) + 1)) + b));
		}
		public static function bounceEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			if (t < (1 / 2.75)){
				return (((c * ((7.5625 * t) * t)) + b));
			};
			if (t < (2 / 2.75)){
				t = (t - (1.5 / 2.75));
				return (((c * (((7.5625 * t) * t) + 0.75)) + b));
			};
			if (t < (2.5 / 2.75)){
				t = (t - (2.25 / 2.75));
				return (((c * (((7.5625 * t) * t) + 0.9375)) + b));
			};
			t = (t - (2.625 / 2.75));
			return (((c * (((7.5625 * t) * t) + 0.984375)) + b));
		}
		public static function backEaseOut(t:Number, b:Number, c:Number, d:Number, s:Number=1.70158):Number{
			t = ((t / d) - 1);
			return (((c * (((t * t) * (((s + 1) * t) + s)) + 1)) + b));
		}
		public static function quadEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return ((((c * t) * t) + b));
		}
		public static function bounceEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			return (((c - bounceEaseOut((d - t), 0, c, d)) + b));
		}
		public static function quartEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return (((((((c / 2) * t) * t) * t) * t) + b));
			};
			t = (t - 2);
			return ((((-(c) / 2) * ((((t * t) * t) * t) - 2)) + b));
		}
		public static function cubicEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return (((((c * t) * t) * t) + b));
		}
		public static function quintEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return (((((((c * t) * t) * t) * t) * t) + b));
		}
		public static function sineEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			return ((((-(c) * Math.cos(((t / d) * (Math.PI / 2)))) + c) + b));
		}
		public static function backEaseIn(t:Number, b:Number, c:Number, d:Number, s:Number=1.70158):Number{
			t = (t / d);
			return (((((c * t) * t) * (((s + 1) * t) - s)) + b));
		}
		public static function elasticEaseIn(t:Number, b:Number, c:Number, d:Number, a:Number, p:Number):Number{
			var s:Number;
			if (t == 0){
				return (b);
			};
			t = (t / d);
			if (t == 1){
				return ((b + c));
			};
			if (!p){
				p = (d * 0.3);
			};
			if (((!(a)) || ((a < Math.abs(c))))){
				a = c;
				s = (p / 4);
			} else {
				s = ((p / (2 * Math.PI)) * Math.asin((c / a)));
			};
			--t;
			return ((-(((a * Math.pow(2, (10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p)))) + b));
		}
		public static function circEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((c * Math.sqrt((1 - (t * t)))) + b));
		}
		public static function circEaseIn(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return (((-(c) * (Math.sqrt((1 - (t * t))) - 1)) + b));
		}
		public static function elasticEaseOut(t:Number, b:Number, c:Number, d:Number, a:Number, p:Number):Number{
			var s:Number;
			if (t == 0){
				return (b);
			};
			t = (t / d);
			if (t == 1){
				return ((b + c));
			};
			if (!p){
				p = (d * 0.3);
			};
			if (((!(a)) || ((a < Math.abs(c))))){
				a = c;
				s = (p / 4);
			} else {
				s = ((p / (2 * Math.PI)) * Math.asin((c / a)));
			};
			return (((((a * Math.pow(2, (-10 * t))) * Math.sin(((((t * d) - s) * (2 * Math.PI)) / p))) + c) + b));
		}
		public static function expoEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			return (((t)==d) ? (b + c) : ((c * (-(Math.pow(2, ((-10 * t) / d))) + 1)) + b));
		}
		public static function cubicEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / (d / 2));
			if (t < 1){
				return ((((((c / 2) * t) * t) * t) + b));
			};
			t = (t - 2);
			return ((((c / 2) * (((t * t) * t) + 2)) + b));
		}
		public static function sineEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			return (((c * Math.sin(((t / d) * (Math.PI / 2)))) + b));
		}
		public static function backEaseInOut(t:Number, b:Number, c:Number, d:Number, s:Number=1.70158):Number{
			t = (t / (d / 2));
			if (t < 1){
				s = (s * 1.525);
				return ((((c / 2) * ((t * t) * (((s + 1) * t) - s))) + b));
			};
			t = (t - 2);
			s = (s * 1.525);
			return ((((c / 2) * (((t * t) * (((s + 1) * t) + s)) + 2)) + b));
		}
		public static function quintEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = ((t / d) - 1);
			return (((c * (((((t * t) * t) * t) * t) + 1)) + b));
		}
		public static function quadEaseOut(t:Number, b:Number, c:Number, d:Number):Number{
			t = (t / d);
			return ((((-(c) * t) * (t - 2)) + b));
		}
		public static function bounceEaseInOut(t:Number, b:Number, c:Number, d:Number):Number{
			if (t < (d / 2)){
				return (((bounceEaseIn((t * 2), 0, c, d) * 0.5) + b));
			};
			return ((((bounceEaseOut(((t * 2) - d), 0, c, d) * 0.5) + (c * 0.5)) + b));
		}

	}
}//package com.roguedevelopment 
Section 158
//FpsCounter (General.FpsCounter)
package General {
	import flash.display.*;
	import flash.utils.*;
	import flash.text.*;
	import flash.system.*;

	public class FpsCounter extends Sprite {

		private var avgCount2:int;// = 30
		private var oldT:uint;
		private var mfpsCount:int;// = 0
		private var textBox2:TextField;
		private var textBox3:TextField;
		private var avgCount:int;// = 30
		private var textBox:TextField;
		private var mfpsCount2:int;// = 0

		public function FpsCounter(){
			super();
			textBox = new TextField();
			textBox.text = "...";
			textBox.textColor = 11145540;
			textBox.selectable = false;
			textBox2 = new TextField();
			textBox2.text = "...";
			textBox2.width = 150;
			textBox2.textColor = 11145540;
			textBox2.selectable = false;
			textBox2.y = 15;
			textBox3 = new TextField();
			textBox3.text = "...";
			textBox3.textColor = 11145540;
			textBox3.selectable = false;
			textBox3.y = 30;
			oldT = getTimer();
			addChild(textBox);
			addChild(textBox2);
			addChild(textBox3);
		}
		public function update():void{
			var newT:uint = getTimer();
			var f1:uint = (newT - oldT);
			mfpsCount = (mfpsCount + f1);
			if (avgCount < 1){
				textBox.text = String((Math.round((1000 / (mfpsCount / 30))) + " fps average"));
				avgCount = 30;
				mfpsCount = 0;
			};
			avgCount--;
			oldT = getTimer();
			textBox3.text = (Math.round((System.totalMemory / (0x0400 * 0x0400))) + " MB used");
		}
		public function updateEnd():void{
		}
		public function updatePhys(oldT2:uint):void{
			var newT:uint = getTimer();
			var f1:uint = (newT - oldT2);
			mfpsCount2 = (mfpsCount2 + f1);
			if (avgCount2 < 1){
				textBox2.text = String((((("Physics step: " + Math.round((mfpsCount2 / 30))) + " ms (") + Math.round((1000 / (mfpsCount2 / 30)))) + " fps)"));
				avgCount2 = 30;
				mfpsCount2 = 0;
			};
			avgCount2--;
		}

	}
}//package General 
Section 159
//FRateLimiter (General.FRateLimiter)
package General {
	import flash.utils.*;

	public class FRateLimiter {

		private static var newT:uint = oldT;
		private static var oldT:uint = getTimer();

		public function FRateLimiter(){
			super();
		}
		public static function limitFrame(maxFPS:uint):void{
			var fTime:uint = (1000 / maxFPS);
			while (Math.abs((newT - oldT)) < fTime) {
				newT = getTimer();
			};
			oldT = getTimer();
		}

	}
}//package General 
Section 160
//Input (General.Input)
package General {
	import flash.events.*;
	import flash.display.*;

	public class Input {

		public static var mouseOffsetX:Number = 0;
		private static var keyArr:Array;
		public static var mouseDragX:Number = 0;
		public static var mouseDragY:Number = 0;
		public static var mouseOffsetY:Number = 0;
		public static var ascii:Array;
		public static var mouseX:Number = 0;
		public static var mouseY:Number = 0;
		public static var mouseOver:Boolean = false;
		private static var bufferSize:int;
		public static var mouse:Sprite = new Sprite();
		public static var mouseDown:Boolean = false;
		public static var mouseReleased:Boolean = false;
		public static var lastKey:int = 0;
		public static var m_stageMc:Sprite;
		private static var keyState:Array;
		public static var timeSinceLastKey = 0;
		public static var mousePressed:Boolean = false;
		private static var keyBuffer:Array;

		public function Input(stageMc:Sprite){
			super();
			m_stageMc = stageMc;
			ascii = new Array(222);
			fillAscii();
			keyState = new Array(222);
			keyArr = new Array();
			var i:int;
			while (i < 222) {
				keyState[i] = new int(0);
				if (ascii[i] != undefined){
					keyArr.push(i);
				};
				i++;
			};
			bufferSize = 5;
			keyBuffer = new Array(bufferSize);
			var j:int;
			while (j < bufferSize) {
				keyBuffer[j] = new Array(0, 0);
				j++;
			};
			stageMc.stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPress, false, 0, true);
			stageMc.stage.addEventListener(KeyboardEvent.KEY_UP, keyRelease, false, 0, true);
			stageMc.stage.addEventListener(MouseEvent.MOUSE_DOWN, mousePress, false, 0, true);
			stageMc.stage.addEventListener(MouseEvent.CLICK, mouseRelease, false, 0, true);
			stageMc.stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMove, false, 0, true);
			stageMc.stage.addEventListener(Event.MOUSE_LEAVE, mouseLeave, false, 0, true);
			mouse.graphics.lineStyle(0.1, 0, 100);
			mouse.graphics.moveTo(0, 0);
			mouse.graphics.lineTo(0, 0.1);
		}
		public function mouseLeave(e:Event){
			mouseReleased = mouseDown;
			mouseDown = false;
		}
		public function keyPress(e:KeyboardEvent){
			keyState[e.keyCode] = Math.max(keyState[e.keyCode], 1);
			lastKey = e.keyCode;
		}
		private function fillAscii(){
			ascii[65] = "A";
			ascii[66] = "B";
			ascii[67] = "C";
			ascii[68] = "D";
			ascii[69] = "E";
			ascii[70] = "F";
			ascii[71] = "G";
			ascii[72] = "H";
			ascii[73] = "I";
			ascii[74] = "J";
			ascii[75] = "K";
			ascii[76] = "L";
			ascii[77] = "M";
			ascii[78] = "N";
			ascii[79] = "O";
			ascii[80] = "P";
			ascii[81] = "Q";
			ascii[82] = "R";
			ascii[83] = "S";
			ascii[84] = "T";
			ascii[85] = "U";
			ascii[86] = "V";
			ascii[87] = "W";
			ascii[88] = "X";
			ascii[89] = "Y";
			ascii[90] = "Z";
			ascii[48] = "0";
			ascii[49] = "1";
			ascii[50] = "2";
			ascii[51] = "3";
			ascii[52] = "4";
			ascii[53] = "5";
			ascii[54] = "6";
			ascii[55] = "7";
			ascii[56] = "8";
			ascii[57] = "9";
			ascii[32] = "Spacebar";
			ascii[17] = "Ctrl";
			ascii[16] = "Shift";
			ascii[192] = "~";
			ascii[38] = "up";
			ascii[40] = "down";
			ascii[37] = "left";
			ascii[39] = "right";
			ascii[96] = "Numpad 0";
			ascii[97] = "Numpad 1";
			ascii[98] = "Numpad 2";
			ascii[99] = "Numpad 3";
			ascii[100] = "Numpad 4";
			ascii[101] = "Numpad 5";
			ascii[102] = "Numpad 6";
			ascii[103] = "Numpad 7";
			ascii[104] = "Numpad 8";
			ascii[105] = "Numpad 9";
			ascii[111] = "Numpad /";
			ascii[106] = "Numpad *";
			ascii[109] = "Numpad -";
			ascii[107] = "Numpad +";
			ascii[110] = "Numpad .";
			ascii[45] = "Insert";
			ascii[46] = "Delete";
			ascii[33] = "Page Up";
			ascii[34] = "Page Down";
			ascii[35] = "End";
			ascii[36] = "Home";
			ascii[112] = "F1";
			ascii[113] = "F2";
			ascii[114] = "F3";
			ascii[115] = "F4";
			ascii[116] = "F5";
			ascii[117] = "F6";
			ascii[118] = "F7";
			ascii[119] = "F8";
			ascii[188] = ",";
			ascii[190] = ".";
			ascii[186] = ";";
			ascii[222] = "'";
			ascii[219] = "[";
			ascii[221] = "]";
			ascii[189] = "-";
			ascii[187] = "+";
			ascii[220] = "\\";
			ascii[191] = "/";
			ascii[9] = "TAB";
			ascii[8] = "Backspace";
		}
		public function mouseMove(e:MouseEvent){
			if (mouseDown != e.buttonDown){
				mouseDown = e.buttonDown;
				mouseReleased = !(e.buttonDown);
				mousePressed = e.buttonDown;
				mouseDragX = 0;
				mouseDragY = 0;
			};
			mouseX = (e.stageX - m_stageMc.x);
			mouseY = (e.stageY - m_stageMc.y);
			mouseOffsetX = (mouseX - mouse.x);
			mouseOffsetY = (mouseY - mouse.y);
			if (mouseDown){
				mouseDragX = (mouseDragX + mouseOffsetX);
				mouseDragY = (mouseDragY + mouseOffsetY);
			};
			mouse.x = mouseX;
			mouse.y = mouseY;
		}
		public function keyRelease(e:KeyboardEvent){
			keyState[e.keyCode] = -1;
			var i:int = (bufferSize - 1);
			while (i > 0) {
				keyBuffer[i] = keyBuffer[(i - 1)];
				i--;
			};
			keyBuffer[0] = [e.keyCode, 0];
		}
		public function mouseRelease(e:MouseEvent){
			mouseDown = false;
			mouseReleased = true;
		}
		public function mousePress(e:MouseEvent){
			mousePressed = true;
			mouseDown = true;
			mouseDragX = 0;
			mouseDragY = 0;
		}

		public static function getKeyHold(k:int):int{
			return (Math.max(0, keyState[k]));
		}
		public static function update(){
			var i:int;
			while (i < keyArr.length) {
				if (keyState[keyArr[i]] != 0){
					var _local3 = keyState;
					var _local4 = keyArr[i];
					var _local5 = (_local3[_local4] + 1);
					_local3[_local4] = _local5;
				};
				i++;
			};
			var j:int;
			while (j < bufferSize) {
				_local3 = keyBuffer[j];
				_local4 = 1;
				_local5 = (_local3[_local4] + 1);
				_local3[_local4] = _local5;
				j++;
			};
			mouseReleased = false;
			mousePressed = false;
			mouseOver = false;
		}
		public static function isKeyPressed(k:int):Boolean{
			timeSinceLastKey = 0;
			return ((keyState[k] == 1));
		}
		public static function isKeyDown(k:int):Boolean{
			return ((keyState[k] > 0));
		}
		public static function getKeyString(k:uint):String{
			return (ascii[k]);
		}
		public static function isKeyReleased(k:int):Boolean{
			return ((keyState[k] == -1));
		}
		public static function isKeyInBuffer(k:int, i:int, t:int){
			return ((((keyBuffer[i][0] == k)) && ((keyBuffer[i][1] <= t))));
		}

	}
}//package General 
Section 161
//MochiAd (mochi.as3.MochiAd)
package mochi.as3 {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;
	import flash.system.*;
	import flash.net.*;

	public class MochiAd {

		public function MochiAd(){
			super();
		}
		public static function getVersion():String{
			return ("3.0 as3");
		}
		public static function showClickAwayAd(options:Object):void{
			var clip:Object;
			var mc:MovieClip;
			var chk:MovieClip;
			var options = options;
			var DEFAULTS:Object = {ad_timeout:2000, regpt:"o", method:"showClickAwayAd", res:"300x250", no_bg:true, ad_started:function ():void{
			}, ad_finished:function ():void{
			}, ad_loaded:function (width:Number, height:Number):void{
			}, ad_failed:function ():void{
				trace("[MochiAd] Couldn't load an ad, make sure your game's local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
			}, ad_skipped:function ():void{
			}};
			options = MochiAd._parseOptions(options, DEFAULTS);
			clip = options.clip;
			var ad_timeout:Number = options.ad_timeout;
			delete options.ad_timeout;
			if (!MochiAd.load(options)){
				options.ad_failed();
				options.ad_finished();
				return;
			};
			options.ad_started();
			mc = clip._mochiad;
			mc["onUnload"] = function ():void{
				MochiAd._cleanup(mc);
				options.ad_finished();
			};
			var wh:Array = MochiAd._getRes(options, clip);
			var w:Number = wh[0];
			var h:Number = wh[1];
			mc.x = (w * 0.5);
			mc.y = (h * 0.5);
			chk = createEmptyMovieClip(mc, "_mochiad_wait", 3);
			chk.ad_timeout = ad_timeout;
			chk.started = getTimer();
			chk.showing = false;
			mc.unloadAd = function ():void{
				MochiAd.unload(clip);
			};
			mc.adLoaded = options.ad_loaded;
			mc.adSkipped = options.ad_skipped;
			mc.rpc = function (callbackID:Number, arg:Object):void{
				MochiAd.rpc(clip, callbackID, arg);
			};
			var sendHostProgress:Boolean;
			mc.regContLC = function (lc_name:String):void{
				mc._containerLCName = lc_name;
			};
			chk["onEnterFrame"] = function ():void{
				var total:Number;
				if (!this.parent){
					delete this.onEnterFrame;
					return;
				};
				var ad_clip:Object = this.parent._mochiad_ctr;
				var elapsed:Number = (getTimer() - this.started);
				var finished:Boolean;
				if (!chk.showing){
					total = this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal;
					if (total > 0){
						chk.showing = true;
						finished = true;
						chk.started = getTimer();
					} else {
						if (elapsed > chk.ad_timeout){
							options.ad_failed();
							finished = true;
						};
					};
				};
				if (this.root == null){
					finished = true;
				};
				if (finished){
					delete this.onEnterFrame;
				};
			};
			doOnEnterFrame(chk);
		}
		public static function _isNetworkAvailable():Boolean{
			return (!((Security.sandboxType == "localWithFile")));
		}
		public static function _allowDomains(server:String):String{
			var hostname:String = server.split("/")[2].split(":")[0];
			if (Security.sandboxType == "application"){
				return (hostname);
			};
			Security.allowDomain("*");
			Security.allowDomain(hostname);
			Security.allowInsecureDomain("*");
			Security.allowInsecureDomain(hostname);
			return (hostname);
		}
		public static function unload(clip:Object):Boolean{
			if (((clip.clip) && (clip.clip._mochiad))){
				clip = clip.clip;
			};
			if (clip.origFrameRate != undefined){
				clip.stage.frameRate = clip.origFrameRate;
			};
			if (!clip._mochiad){
				return (false);
			};
			if (clip._mochiad._containerLCName != undefined){
				clip._mochiad.lc.send(clip._mochiad._containerLCName, "notify", {id:"unload"});
			};
			if (clip._mochiad.onUnload){
				clip._mochiad.onUnload();
			};
			delete clip._mochiad_loaded;
			delete clip._mochiad;
			return (true);
		}
		public static function showInterLevelAd(options:Object):void{
			var clip:Object;
			var mc:MovieClip;
			var chk:MovieClip;
			var options = options;
			var DEFAULTS:Object = {ad_timeout:2000, fadeout_time:250, regpt:"o", method:"showTimedAd", ad_started:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.stop();
				} else {
					throw (new Error("MochiAd.showInterLevelAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_finished:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.play();
				} else {
					throw (new Error("MochiAd.showInterLevelAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_loaded:function (width:Number, height:Number):void{
			}, ad_failed:function ():void{
				trace("[MochiAd] Couldn't load an ad, make sure your game's local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
			}, ad_skipped:function ():void{
			}};
			options = MochiAd._parseOptions(options, DEFAULTS);
			clip = options.clip;
			var ad_msec:Number = 11000;
			var ad_timeout:Number = options.ad_timeout;
			delete options.ad_timeout;
			var fadeout_time:Number = options.fadeout_time;
			delete options.fadeout_time;
			if (!MochiAd.load(options)){
				options.ad_failed();
				options.ad_finished();
				return;
			};
			options.ad_started();
			mc = clip._mochiad;
			mc["onUnload"] = function ():void{
				MochiAd._cleanup(mc);
				options.ad_finished();
			};
			var wh:Array = MochiAd._getRes(options, clip);
			var w:Number = wh[0];
			var h:Number = wh[1];
			mc.x = (w * 0.5);
			mc.y = (h * 0.5);
			chk = createEmptyMovieClip(mc, "_mochiad_wait", 3);
			chk.ad_msec = ad_msec;
			chk.ad_timeout = ad_timeout;
			chk.started = getTimer();
			chk.showing = false;
			chk.fadeout_time = fadeout_time;
			chk.fadeFunction = function ():void{
				if (!this.parent){
					delete this.onEnterFrame;
					delete this.fadeFunction;
					return;
				};
				var p:Number = (100 * (1 - ((getTimer() - this.fadeout_start) / this.fadeout_time)));
				if (p > 0){
					this.parent.alpha = (p * 0.01);
				} else {
					MochiAd.unload(clip);
					delete this["onEnterFrame"];
				};
			};
			mc.unloadAd = function ():void{
				MochiAd.unload(clip);
			};
			mc.adLoaded = options.ad_loaded;
			mc.adSkipped = options.ad_skipped;
			mc.adjustProgress = function (msec:Number):void{
				var _chk:Object = mc._mochiad_wait;
				_chk.server_control = true;
				_chk.showing = true;
				_chk.started = getTimer();
				_chk.ad_msec = (msec - 250);
			};
			mc.rpc = function (callbackID:Number, arg:Object):void{
				MochiAd.rpc(clip, callbackID, arg);
			};
			chk["onEnterFrame"] = function ():void{
				var total:Number;
				if (!this.parent){
					delete this.onEnterFrame;
					delete this.fadeFunction;
					return;
				};
				var ad_clip:Object = this.parent._mochiad_ctr;
				var elapsed:Number = (getTimer() - this.started);
				var finished:Boolean;
				if (!chk.showing){
					total = this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal;
					if (total > 0){
						chk.showing = true;
						chk.started = getTimer();
						MochiAd.adShowing(clip);
					} else {
						if (elapsed > chk.ad_timeout){
							options.ad_failed();
							finished = true;
						};
					};
				};
				if (elapsed > chk.ad_msec){
					finished = true;
				};
				if (finished){
					if (this.server_control){
						delete this.onEnterFrame;
					} else {
						this.fadeout_start = getTimer();
						this.onEnterFrame = this.fadeFunction;
					};
				};
			};
			doOnEnterFrame(chk);
		}
		public static function _parseOptions(options:Object, defaults:Object):Object{
			var k:String;
			var pairs:Array;
			var i:Number;
			var kv:Array;
			var optcopy:Object = {};
			for (k in defaults) {
				optcopy[k] = defaults[k];
			};
			if (options){
				for (k in options) {
					optcopy[k] = options[k];
				};
			};
			if (optcopy.clip == undefined){
				throw (new Error("MochiAd is missing the 'clip' parameter.  This should be a MovieClip, Sprite or an instance of a class that extends MovieClip or Sprite."));
			};
			options = optcopy.clip.loaderInfo.parameters.mochiad_options;
			if (options){
				pairs = options.split("&");
				i = 0;
				while (i < pairs.length) {
					kv = pairs[i].split("=");
					optcopy[unescape(kv[0])] = unescape(kv[1]);
					i++;
				};
			};
			if (optcopy.id == "test"){
				trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
			};
			return (optcopy);
		}
		public static function _cleanup(mc:Object):void{
			var k:String;
			var lc:LocalConnection;
			var f:Function;
			var mc = mc;
			if (("lc" in mc)){
				lc = mc.lc;
				f = function ():void{
					lc.client = null;
					lc.close();
					//unresolved jump
					var _slot1 = e;
				};
				setTimeout(f, 0);
			};
			var idx:Number = DisplayObjectContainer(mc).numChildren;
			while (idx > 0) {
				idx = (idx - 1);
				DisplayObjectContainer(mc).removeChildAt(idx);
			};
			for (k in mc) {
				delete mc[k];
			};
		}
		public static function load(options:Object):MovieClip{
			var clip:Object;
			var k:String;
			var server:String;
			var hostname:String;
			var lc:LocalConnection;
			var name:String;
			var loader:Loader;
			var g:Function;
			var req:URLRequest;
			var v:Object;
			var options = options;
			var DEFAULTS:Object = {server:"http://x.mochiads.com/srv/1/", method:"load", depth:10333, id:"_UNKNOWN_"};
			options = MochiAd._parseOptions(options, DEFAULTS);
			options.swfv = 9;
			options.mav = MochiAd.getVersion();
			clip = options.clip;
			if (!MochiAd._isNetworkAvailable()){
				return (null);
			};
			if (clip._mochiad_loaded){
				return (null);
			};
			//unresolved jump
			var _slot1 = e;
			throw (new Error("MochiAd requires a clip that is an instance of a dynamic class.  If your class extends Sprite or MovieClip, you must make it dynamic."));
			var depth:Number = options.depth;
			delete options.depth;
			var mc:MovieClip = createEmptyMovieClip(clip, "_mochiad", depth);
			var wh:Array = MochiAd._getRes(options, clip);
			options.res = ((wh[0] + "x") + wh[1]);
			options.server = (options.server + options.id);
			delete options.id;
			clip._mochiad_loaded = true;
			if (clip.loaderInfo.loaderURL.indexOf("http") == 0){
				options.as3_swf = clip.loaderInfo.loaderURL;
			} else {
				trace("[MochiAd] NOTE: Security Sandbox Violation errors below are normal");
			};
			var lv:URLVariables = new URLVariables();
			for (k in options) {
				v = options[k];
				if (!(v is Function)){
					lv[k] = v;
				};
			};
			server = lv.server;
			delete lv.server;
			hostname = _allowDomains(server);
			lc = new LocalConnection();
			lc.client = mc;
			name = ["", Math.floor(new Date().getTime()), Math.floor((Math.random() * 999999))].join("_");
			lc.allowDomain("*", "localhost");
			lc.allowInsecureDomain("*", "localhost");
			lc.connect(name);
			mc.lc = lc;
			mc.lcName = name;
			lv.lc = name;
			lv.st = getTimer();
			loader = new Loader();
			g = function (ev:Object):void{
				ev.target.removeEventListener(ev.type, arguments.callee);
				MochiAd.unload(clip);
			};
			loader.contentLoaderInfo.addEventListener(Event.UNLOAD, g);
			req = new URLRequest(((server + ".swf?cacheBust=") + new Date().getTime()));
			req.contentType = "application/x-www-form-urlencoded";
			req.method = URLRequestMethod.POST;
			req.data = lv;
			loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, function (io:IOErrorEvent):void{
				trace("[MochiAds] Blocked URL");
			});
			loader.load(req);
			mc.addChild(loader);
			mc._mochiad_ctr = loader;
			return (mc);
		}
		public static function runMethod(base:Object, methodName:String, argsArray:Array):Object{
			var nameArray:Array = methodName.split(".");
			var i:Number = 0;
			while (i < (nameArray.length - 1)) {
				if ((((base[nameArray[i]] == undefined)) || ((base[nameArray[i]] == null)))){
					return (undefined);
				};
				base = base[nameArray[i]];
				i++;
			};
			if (typeof(base[nameArray[i]]) == "function"){
				return (base[nameArray[i]].apply(base, argsArray));
			};
			return (undefined);
		}
		public static function createEmptyMovieClip(parent:Object, name:String, depth:Number):MovieClip{
			var mc:MovieClip = new MovieClip();
			if (((false) && (depth))){
				parent.addChildAt(mc, depth);
			} else {
				parent.addChild(mc);
			};
			parent[name] = mc;
			mc["_name"] = name;
			return (mc);
		}
		public static function _getRes(options:Object, clip:Object):Array{
			var xy:Array;
			var b:Object = clip.getBounds(clip.root);
			var w:Number = 0;
			var h:Number = 0;
			if (typeof(options.res) != "undefined"){
				xy = options.res.split("x");
				w = parseFloat(xy[0]);
				h = parseFloat(xy[1]);
			} else {
				w = (b.xMax - b.xMin);
				h = (b.yMax - b.yMin);
			};
			if ((((w == 0)) || ((h == 0)))){
				w = clip.stage.stageWidth;
				h = clip.stage.stageHeight;
			};
			return ([w, h]);
		}
		public static function adShowing(mc:Object):void{
			mc.origFrameRate = mc.stage.frameRate;
			mc.stage.frameRate = 30;
		}
		public static function getValue(base:Object, objectName:String):Object{
			var nameArray:Array = objectName.split(".");
			var i:Number = 0;
			while (i < (nameArray.length - 1)) {
				if ((((base[nameArray[i]] == undefined)) || ((base[nameArray[i]] == null)))){
					return (undefined);
				};
				base = base[nameArray[i]];
				i++;
			};
			return (base[nameArray[i]]);
		}
		public static function rpc(clip:Object, callbackID:Number, arg:Object):void{
			var _local4:Object;
			var _local5:Object;
			switch (arg.id){
				case "setValue":
					MochiAd.setValue(clip, arg.objectName, arg.value);
					break;
				case "getValue":
					_local4 = MochiAd.getValue(clip, arg.objectName);
					clip._mochiad.lc.send(clip._mochiad._containerLCName, "rpcResult", callbackID, _local4);
					break;
				case "runMethod":
					_local5 = MochiAd.runMethod(clip, arg.method, arg.args);
					clip._mochiad.lc.send(clip._mochiad._containerLCName, "rpcResult", callbackID, _local5);
					break;
				default:
					trace(("[mochiads rpc] unknown rpc id: " + arg.id));
			};
		}
		public static function setValue(base:Object, objectName:String, value:Object):void{
			var nameArray:Array = objectName.split(".");
			var i:Number = 0;
			while (i < (nameArray.length - 1)) {
				if ((((base[nameArray[i]] == undefined)) || ((base[nameArray[i]] == null)))){
					return;
				};
				base = base[nameArray[i]];
				i++;
			};
			base[nameArray[i]] = value;
		}
		public static function showPreGameAd(options:Object):void{
			var clip:Object;
			var mc:MovieClip;
			var chk:MovieClip;
			var complete:Boolean;
			var unloaded:Boolean;
			var sendHostProgress:Boolean;
			var fn:Function;
			var r:MovieClip;
			var options = options;
			var DEFAULTS:Object = {ad_timeout:3000, fadeout_time:250, regpt:"o", method:"showPreloaderAd", color:0xFF8A00, background:16777161, outline:13994812, no_progress_bar:false, ad_started:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.stop();
				} else {
					throw (new Error("MochiAd.showPreGameAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_finished:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.play();
				} else {
					throw (new Error("MochiAd.showPreGameAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_loaded:function (width:Number, height:Number):void{
			}, ad_failed:function ():void{
				trace("[MochiAd] Couldn't load an ad, make sure your game's local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
			}, ad_skipped:function ():void{
			}, ad_progress:function (percent:Number):void{
			}};
			options = MochiAd._parseOptions(options, DEFAULTS);
			if ("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def"){
				options.ad_started();
				fn = function ():void{
					options.ad_finished();
				};
				setTimeout(fn, 100);
				return;
			};
			clip = options.clip;
			var ad_msec:Number = 11000;
			var ad_timeout:Number = options.ad_timeout;
			delete options.ad_timeout;
			var fadeout_time:Number = options.fadeout_time;
			delete options.fadeout_time;
			if (!MochiAd.load(options)){
				options.ad_failed();
				options.ad_finished();
				return;
			};
			options.ad_started();
			mc = clip._mochiad;
			mc["onUnload"] = function ():void{
				MochiAd._cleanup(mc);
				var fn:Function = function ():void{
					options.ad_finished();
				};
				setTimeout(fn, 100);
			};
			var wh:Array = MochiAd._getRes(options, clip);
			var w:Number = wh[0];
			var h:Number = wh[1];
			mc.x = (w * 0.5);
			mc.y = (h * 0.5);
			chk = createEmptyMovieClip(mc, "_mochiad_wait", 3);
			chk.x = (w * -0.5);
			chk.y = (h * -0.5);
			var bar:MovieClip = createEmptyMovieClip(chk, "_mochiad_bar", 4);
			if (options.no_progress_bar){
				bar.visible = false;
				delete options.no_progress_bar;
			} else {
				bar.x = 10;
				bar.y = (h - 20);
			};
			var bar_color:Number = options.color;
			delete options.color;
			var bar_background:Number = options.background;
			delete options.background;
			var bar_outline:Number = options.outline;
			delete options.outline;
			var backing_mc:MovieClip = createEmptyMovieClip(bar, "_outline", 1);
			var backing:Object = backing_mc.graphics;
			backing.beginFill(bar_background);
			backing.moveTo(0, 0);
			backing.lineTo((w - 20), 0);
			backing.lineTo((w - 20), 10);
			backing.lineTo(0, 10);
			backing.lineTo(0, 0);
			backing.endFill();
			var inside_mc:MovieClip = createEmptyMovieClip(bar, "_inside", 2);
			var inside:Object = inside_mc.graphics;
			inside.beginFill(bar_color);
			inside.moveTo(0, 0);
			inside.lineTo((w - 20), 0);
			inside.lineTo((w - 20), 10);
			inside.lineTo(0, 10);
			inside.lineTo(0, 0);
			inside.endFill();
			inside_mc.scaleX = 0;
			var outline_mc:MovieClip = createEmptyMovieClip(bar, "_outline", 3);
			var outline:Object = outline_mc.graphics;
			outline.lineStyle(0, bar_outline, 100);
			outline.moveTo(0, 0);
			outline.lineTo((w - 20), 0);
			outline.lineTo((w - 20), 10);
			outline.lineTo(0, 10);
			outline.lineTo(0, 0);
			chk.ad_msec = ad_msec;
			chk.ad_timeout = ad_timeout;
			chk.started = getTimer();
			chk.showing = false;
			chk.last_pcnt = 0;
			chk.fadeout_time = fadeout_time;
			chk.fadeFunction = function ():void{
				var p:Number = (100 * (1 - ((getTimer() - this.fadeout_start) / this.fadeout_time)));
				if (p > 0){
					this.parent.alpha = (p * 0.01);
				} else {
					MochiAd.unload(clip);
					delete this["onEnterFrame"];
				};
			};
			complete = false;
			unloaded = false;
			var f:Function = function (ev:Event):void{
				ev.target.removeEventListener(ev.type, arguments.callee);
				complete = true;
				if (unloaded){
					MochiAd.unload(clip);
				};
			};
			clip.loaderInfo.addEventListener(Event.COMPLETE, f);
			if ((clip.root is MovieClip)){
				r = (clip.root as MovieClip);
				if (r.framesLoaded >= r.totalFrames){
					complete = true;
				};
			};
			mc.unloadAd = function ():void{
				unloaded = true;
				if (complete){
					MochiAd.unload(clip);
				};
			};
			mc.adLoaded = options.ad_loaded;
			mc.adSkipped = options.ad_skipped;
			mc.adjustProgress = function (msec:Number):void{
				var _chk:Object = mc._mochiad_wait;
				_chk.server_control = true;
				_chk.showing = true;
				_chk.started = getTimer();
				_chk.ad_msec = msec;
			};
			mc.rpc = function (callbackID:Number, arg:Object):void{
				MochiAd.rpc(clip, callbackID, arg);
			};
			mc.rpcTestFn = function (s:String):Object{
				trace(("[MOCHIAD rpcTestFn] " + s));
				return (s);
			};
			mc.regContLC = function (lc_name:String):void{
				mc._containerLCName = lc_name;
			};
			sendHostProgress = false;
			mc.sendHostLoadProgress = function (lc_name:String):void{
				sendHostProgress = true;
			};
			chk["onEnterFrame"] = function ():void{
				var total:Number;
				if (((!(this.parent)) || (!(this.parent.parent)))){
					delete this["onEnterFrame"];
					return;
				};
				var _clip:Object = this.parent.parent.root;
				var ad_clip:Object = this.parent._mochiad_ctr;
				var elapsed:Number = (getTimer() - this.started);
				var finished:Boolean;
				var clip_total:Number = _clip.loaderInfo.bytesTotal;
				var clip_loaded:Number = _clip.loaderInfo.bytesLoaded;
				if (complete){
					clip_loaded = Math.max(1, clip_loaded);
					clip_total = clip_loaded;
				};
				var clip_pcnt:Number = ((100 * clip_loaded) / clip_total);
				var ad_pcnt:Number = ((100 * elapsed) / chk.ad_msec);
				var _inside:Object = this._mochiad_bar._inside;
				var pcnt:Number = Math.min(100, Math.min(((clip_pcnt) || (0)), ad_pcnt));
				pcnt = Math.max(this.last_pcnt, pcnt);
				this.last_pcnt = pcnt;
				_inside.scaleX = (pcnt * 0.01);
				options.ad_progress(pcnt);
				if (sendHostProgress){
					clip._mochiad.lc.send(clip._mochiad._containerLCName, "notify", {id:"hostLoadPcnt", pcnt:clip_pcnt});
					if (clip_pcnt == 100){
						sendHostProgress = false;
					};
				};
				if (!chk.showing){
					total = this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal;
					if (total > 0){
						chk.showing = true;
						chk.started = getTimer();
						MochiAd.adShowing(clip);
					} else {
						if ((((elapsed > chk.ad_timeout)) && ((clip_pcnt == 100)))){
							options.ad_failed();
							finished = true;
						};
					};
				};
				if (elapsed > chk.ad_msec){
					finished = true;
				};
				if (((complete) && (finished))){
					if (this.server_control){
						delete this.onEnterFrame;
					} else {
						this.fadeout_start = getTimer();
						this.onEnterFrame = chk.fadeFunction;
					};
				};
			};
			doOnEnterFrame(chk);
		}
		public static function showPreloaderAd(options:Object):void{
			trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
			MochiAd.showPreGameAd(options);
		}
		public static function showTimedAd(options:Object):void{
			trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
			MochiAd.showInterLevelAd(options);
		}
		public static function doOnEnterFrame(mc:MovieClip):void{
			var mc = mc;
			var f:Function = function (ev:Object):void{
				if (((("onEnterFrame" in mc)) && (mc.onEnterFrame))){
					mc.onEnterFrame();
				} else {
					ev.target.removeEventListener(ev.type, arguments.callee);
				};
			};
			mc.addEventListener(Event.ENTER_FRAME, f);
		}

	}
}//package mochi.as3 
Section 162
//BitmapAsset (mx.core.BitmapAsset)
package mx.core {
	import flash.display.*;

	public class BitmapAsset extends FlexBitmap implements IFlexAsset, IFlexDisplayObject {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function BitmapAsset(bitmapData:BitmapData=null, pixelSnapping:String="auto", smoothing:Boolean=false){
			super(bitmapData, pixelSnapping, smoothing);
		}
		public function get measuredWidth():Number{
			if (bitmapData){
				return (bitmapData.width);
			};
			return (0);
		}
		public function get measuredHeight():Number{
			if (bitmapData){
				return (bitmapData.height);
			};
			return (0);
		}
		public function setActualSize(newWidth:Number, newHeight:Number):void{
			width = newWidth;
			height = newHeight;
		}
		public function move(x:Number, y:Number):void{
			this.x = x;
			this.y = y;
		}

	}
}//package mx.core 
Section 163
//ByteArrayAsset (mx.core.ByteArrayAsset)
package mx.core {
	import flash.utils.*;

	public class ByteArrayAsset extends ByteArray implements IFlexAsset {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function ByteArrayAsset(){
			super();
		}
	}
}//package mx.core 
Section 164
//EdgeMetrics (mx.core.EdgeMetrics)
package mx.core {

	public class EdgeMetrics {

		public var top:Number;
		public var left:Number;
		public var bottom:Number;
		public var right:Number;

		mx_internal static const VERSION:String = "3.0.0.0";
		public static const EMPTY:EdgeMetrics = new EdgeMetrics(0, 0, 0, 0);
;

		public function EdgeMetrics(left:Number=0, top:Number=0, right:Number=0, bottom:Number=0){
			super();
			this.left = left;
			this.top = top;
			this.right = right;
			this.bottom = bottom;
		}
		public function clone():EdgeMetrics{
			return (new EdgeMetrics(left, top, right, bottom));
		}

	}
}//package mx.core 
Section 165
//FlexBitmap (mx.core.FlexBitmap)
package mx.core {
	import flash.display.*;
	import mx.utils.*;

	public class FlexBitmap extends Bitmap {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function FlexBitmap(bitmapData:BitmapData=null, pixelSnapping:String="auto", smoothing:Boolean=false){
			var bitmapData = bitmapData;
			var pixelSnapping = pixelSnapping;
			var smoothing = smoothing;
			super(bitmapData, pixelSnapping, smoothing);
			name = NameUtil.createUniqueName(this);
			//unresolved jump
			var _slot1 = e;
		}
		override public function toString():String{
			return (NameUtil.displayObjectToString(this));
		}

	}
}//package mx.core 
Section 166
//FlexMovieClip (mx.core.FlexMovieClip)
package mx.core {
	import flash.display.*;
	import mx.utils.*;

	public class FlexMovieClip extends MovieClip {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function FlexMovieClip(){
			super();
			name = NameUtil.createUniqueName(this);
			//unresolved jump
			var _slot1 = e;
		}
		override public function toString():String{
			return (NameUtil.displayObjectToString(this));
		}

	}
}//package mx.core 
Section 167
//FlexSprite (mx.core.FlexSprite)
package mx.core {
	import flash.display.*;
	import mx.utils.*;

	public class FlexSprite extends Sprite {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function FlexSprite(){
			super();
			name = NameUtil.createUniqueName(this);
			//unresolved jump
			var _slot1 = e;
		}
		override public function toString():String{
			return (NameUtil.displayObjectToString(this));
		}

	}
}//package mx.core 
Section 168
//FontAsset (mx.core.FontAsset)
package mx.core {
	import flash.text.*;

	public class FontAsset extends Font implements IFlexAsset {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function FontAsset(){
			super();
		}
	}
}//package mx.core 
Section 169
//IBorder (mx.core.IBorder)
package mx.core {

	public interface IBorder {

		function get borderMetrics():EdgeMetrics;

	}
}//package mx.core 
Section 170
//IFlexAsset (mx.core.IFlexAsset)
package mx.core {

	public interface IFlexAsset {

	}
}//package mx.core 
Section 171
//IFlexDisplayObject (mx.core.IFlexDisplayObject)
package mx.core {
	import flash.events.*;
	import flash.display.*;
	import flash.geom.*;
	import flash.accessibility.*;

	public interface IFlexDisplayObject extends IBitmapDrawable, IEventDispatcher {

		function get visible():Boolean;
		function get rotation():Number;
		function localToGlobal(void:Point):Point;
		function get name():String;
		function set width(flash.display:Number):void;
		function get measuredHeight():Number;
		function get blendMode():String;
		function get scale9Grid():Rectangle;
		function set name(flash.display:String):void;
		function set scaleX(flash.display:Number):void;
		function set scaleY(flash.display:Number):void;
		function get measuredWidth():Number;
		function get accessibilityProperties():AccessibilityProperties;
		function set scrollRect(flash.display:Rectangle):void;
		function get cacheAsBitmap():Boolean;
		function globalToLocal(void:Point):Point;
		function get height():Number;
		function set blendMode(flash.display:String):void;
		function get parent():DisplayObjectContainer;
		function getBounds(String:DisplayObject):Rectangle;
		function get opaqueBackground():Object;
		function set scale9Grid(flash.display:Rectangle):void;
		function setActualSize(_arg1:Number, _arg2:Number):void;
		function set alpha(flash.display:Number):void;
		function set accessibilityProperties(flash.display:AccessibilityProperties):void;
		function get width():Number;
		function hitTestPoint(_arg1:Number, _arg2:Number, _arg3:Boolean=false):Boolean;
		function set cacheAsBitmap(flash.display:Boolean):void;
		function get scaleX():Number;
		function get scaleY():Number;
		function get scrollRect():Rectangle;
		function get mouseX():Number;
		function get mouseY():Number;
		function set height(flash.display:Number):void;
		function set mask(flash.display:DisplayObject):void;
		function getRect(String:DisplayObject):Rectangle;
		function get alpha():Number;
		function set transform(flash.display:Transform):void;
		function move(_arg1:Number, _arg2:Number):void;
		function get loaderInfo():LoaderInfo;
		function get root():DisplayObject;
		function hitTestObject(mx.core:IFlexDisplayObject/mx.core:IFlexDisplayObject:stage/get:DisplayObject):Boolean;
		function set opaqueBackground(flash.display:Object):void;
		function set visible(flash.display:Boolean):void;
		function get mask():DisplayObject;
		function set x(flash.display:Number):void;
		function set y(flash.display:Number):void;
		function get transform():Transform;
		function set filters(flash.display:Array):void;
		function get x():Number;
		function get y():Number;
		function get filters():Array;
		function set rotation(flash.display:Number):void;
		function get stage():Stage;

	}
}//package mx.core 
Section 172
//IRepeaterClient (mx.core.IRepeaterClient)
package mx.core {

	public interface IRepeaterClient {

		function get instanceIndices():Array;
		function set instanceIndices(E:\dev\3.0.x\frameworks\projects\framework\src;mx\core;IRepeaterClient.as:Array):void;
		function get isDocument():Boolean;
		function set repeaters(E:\dev\3.0.x\frameworks\projects\framework\src;mx\core;IRepeaterClient.as:Array):void;
		function initializeRepeaterArrays(E:\dev\3.0.x\frameworks\projects\framework\src;mx\core;IRepeaterClient.as:IRepeaterClient):void;
		function get repeaters():Array;
		function set repeaterIndices(E:\dev\3.0.x\frameworks\projects\framework\src;mx\core;IRepeaterClient.as:Array):void;
		function get repeaterIndices():Array;

	}
}//package mx.core 
Section 173
//MovieClipAsset (mx.core.MovieClipAsset)
package mx.core {

	public class MovieClipAsset extends FlexMovieClip implements IFlexAsset, IFlexDisplayObject, IBorder {

		private var _measuredHeight:Number;
		private var _measuredWidth:Number;

		mx_internal static const VERSION:String = "3.0.0.0";

		public function MovieClipAsset(){
			super();
			_measuredWidth = width;
			_measuredHeight = height;
		}
		public function get measuredWidth():Number{
			return (_measuredWidth);
		}
		public function get measuredHeight():Number{
			return (_measuredHeight);
		}
		public function setActualSize(newWidth:Number, newHeight:Number):void{
			width = newWidth;
			height = newHeight;
		}
		public function move(x:Number, y:Number):void{
			this.x = x;
			this.y = y;
		}
		public function get borderMetrics():EdgeMetrics{
			if (scale9Grid == null){
				return (EdgeMetrics.EMPTY);
			};
			return (new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil((measuredWidth - scale9Grid.right)), Math.ceil((measuredHeight - scale9Grid.bottom))));
		}

	}
}//package mx.core 
Section 174
//MovieClipLoaderAsset (mx.core.MovieClipLoaderAsset)
package mx.core {
	import flash.events.*;
	import flash.display.*;
	import flash.utils.*;
	import flash.system.*;

	public class MovieClipLoaderAsset extends MovieClipAsset implements IFlexAsset, IFlexDisplayObject {

		protected var initialHeight:Number;// = 0
		private var loader:Loader;// = null
		private var initialized:Boolean;// = false
		protected var initialWidth:Number;// = 0
		private var requestedHeight:Number;
		private var requestedWidth:Number;

		mx_internal static const VERSION:String = "3.0.0.0";

		public function MovieClipLoaderAsset(){
			super();
			var loaderContext:LoaderContext = new LoaderContext();
			loaderContext.applicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
			if (("allowLoadBytesCodeExecution" in loaderContext)){
				loaderContext["allowLoadBytesCodeExecution"] = true;
			};
			loader = new Loader();
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler);
			loader.loadBytes(movieClipData, loaderContext);
			addChild(loader);
		}
		override public function get width():Number{
			if (!initialized){
				return (initialWidth);
			};
			return (super.width);
		}
		override public function set width(value:Number):void{
			if (!initialized){
				requestedWidth = value;
			} else {
				loader.width = value;
			};
		}
		override public function get measuredHeight():Number{
			return (initialHeight);
		}
		private function completeHandler(event:Event):void{
			initialized = true;
			initialWidth = loader.width;
			initialHeight = loader.height;
			if (!isNaN(requestedWidth)){
				loader.width = requestedWidth;
			};
			if (!isNaN(requestedHeight)){
				loader.height = requestedHeight;
			};
			dispatchEvent(event);
		}
		override public function set height(value:Number):void{
			if (!initialized){
				requestedHeight = value;
			} else {
				loader.height = value;
			};
		}
		override public function get measuredWidth():Number{
			return (initialWidth);
		}
		override public function get height():Number{
			if (!initialized){
				return (initialHeight);
			};
			return (super.height);
		}
		public function get movieClipData():ByteArray{
			return (null);
		}

	}
}//package mx.core 
Section 175
//mx_internal (mx.core.mx_internal)
package mx.core {

	public namespace mx_internal = "http://www.adobe.com/2006/flex/mx/internal";
}//package mx.core 
Section 176
//SoundAsset (mx.core.SoundAsset)
package mx.core {
	import flash.media.*;

	public class SoundAsset extends Sound implements IFlexAsset {

		mx_internal static const VERSION:String = "3.0.0.0";

		public function SoundAsset(){
			super();
		}
	}
}//package mx.core 
Section 177
//SpriteAsset (mx.core.SpriteAsset)
package mx.core {

	public class SpriteAsset extends FlexSprite implements IFlexAsset, IFlexDisplayObject, IBorder {

		private var _measuredHeight:Number;
		private var _measuredWidth:Number;

		mx_internal static const VERSION:String = "3.0.0.0";

		public function SpriteAsset(){
			super();
			_measuredWidth = width;
			_measuredHeight = height;
		}
		public function get measuredWidth():Number{
			return (_measuredWidth);
		}
		public function get measuredHeight():Number{
			return (_measuredHeight);
		}
		public function setActualSize(newWidth:Number, newHeight:Number):void{
			width = newWidth;
			height = newHeight;
		}
		public function move(x:Number, y:Number):void{
			this.x = x;
			this.y = y;
		}
		public function get borderMetrics():EdgeMetrics{
			if (scale9Grid == null){
				return (EdgeMetrics.EMPTY);
			};
			return (new EdgeMetrics(scale9Grid.left, scale9Grid.top, Math.ceil((measuredWidth - scale9Grid.right)), Math.ceil((measuredHeight - scale9Grid.bottom))));
		}

	}
}//package mx.core 
Section 178
//NameUtil (mx.utils.NameUtil)
package mx.utils {
	import flash.display.*;
	import mx.core.*;
	import flash.utils.*;

	public class NameUtil {

		mx_internal static const VERSION:String = "3.0.0.0";

		private static var counter:int = 0;

		public function NameUtil(){
			super();
		}
		public static function displayObjectToString(displayObject:DisplayObject):String{
			var result:String;
			var s:String;
			var indices:Array;
			var o:DisplayObject = displayObject;
			while (o != null) {
				if (((((o.parent) && (o.stage))) && ((o.parent == o.stage)))){
					break;
				};
				s = o.name;
				if ((o is IRepeaterClient)){
					indices = IRepeaterClient(o).instanceIndices;
					if (indices){
						s = (s + (("[" + indices.join("][")) + "]"));
					};
				};
				result = ((result == null)) ? s : ((s + ".") + result);
				o = o.parent;
			};
			return (result);
		}
		public static function createUniqueName(object:Object):String{
			if (!object){
				return (null);
			};
			var name:String = getQualifiedClassName(object);
			var index:int = name.indexOf("::");
			if (index != -1){
				name = name.substr((index + 2));
			};
			var charCode:int = name.charCodeAt((name.length - 1));
			if ((((charCode >= 48)) && ((charCode <= 57)))){
				name = (name + "_");
			};
			return ((name + counter++));
		}

	}
}//package mx.utils 
Section 179
//b2zUserData (zahid.games.common.b2zUserData)
package zahid.games.common {

	public class b2zUserData {

		public var isSensor;// = false
		public var vergin:Boolean;// = true
		public var type:String;
		public var name:String;

		public function b2zUserData(pname:String=null, ptype:String=null, pvergin:Boolean=true){
			super();
			name = pname;
			type = ptype;
			vergin = pvergin;
		}
	}
}//package zahid.games.common 
Section 180
//zbox (zahid.games.game59.item.shape.zbox)
package zahid.games.game59.item.shape {
	import flash.geom.*;
	import zahid.games.game59.item.*;

	public class zbox extends zitem {

		public function zbox(m_world, renderer, ppoints:Array, pscale, userdata, meterial){
			super(m_world, renderer, ppoints, meterial, pscale, userdata);
			var tp1:* = new Point(points[0].x, points[0].y);
			var tp2:* = new Point(points[1].x, points[1].y);
			if ((((((tp1.y > tp2.y)) && ((tp1.x < tp2.x)))) || ((((tp1.y < tp2.y)) && ((tp1.x > tp2.x)))))){
				points = new Array(tp1, new Point(tp1.x, tp2.y), tp2, new Point(tp2.x, tp1.y));
			} else {
				points = new Array(tp1, new Point(tp2.x, tp1.y), tp2, new Point(tp1.x, tp2.y));
			};
			makeShapes();
		}
		override public function makeShapes():void{
			var tempPoints:Array = new Array();
			var i:* = 0;
			while (i < points.length) {
				tempPoints.push(new Point(((points[i].x - points[0].x) / scale), ((points[i].y - points[1].y) / scale)));
				i++;
			};
			meterial.mltDef.SetAsZShape(tempPoints);
			body.CreateShape(meterial.mltDef);
			if (userdata.type == "sensor"){
				setAsSensor();
			};
			zSetMassFromShapes();
		}
		override public function SetSkin(shade:String=null, color=0xD2D2D2, alpha=1, pskin=null){
			var i:*;
			skin.graphics.clear();
			switch (shade){
				case "none":
					break;
				case "solid":
					skin.x = points[0].x;
					skin.y = points[0].y;
					skin.graphics.beginFill(color, alpha);
					skin.graphics.moveTo(0, 0);
					i = 1;
					while (i < points.length) {
						skin.graphics.lineTo((points[i].x - points[0].x), (points[i].y - points[0].y));
						i++;
					};
					skin.graphics.endFill();
					break;
				case "bitmap":
					if (pskin != null){
						skin.x = points[0].x;
						skin.y = points[0].y;
						skin.graphics.beginBitmapFill(pskin.bitmapData);
						skin.graphics.moveTo(0, 0);
						i = 1;
						while (i < points.length) {
							skin.graphics.lineTo((points[i].x - points[0].x), (points[i].y - points[0].y));
							i++;
						};
						skin.graphics.endFill();
					};
					break;
			};
		}

	}
}//package zahid.games.game59.item.shape 
Section 181
//zcircle (zahid.games.game59.item.shape.zcircle)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import Box2D.Collision.Shapes.*;
	import zahid.games.game59.item.*;

	public class zcircle extends zitem {

		private var highlighterSkinClass:Class;
		private var shadowSkinClass:Class;

		public function zcircle(m_world, renderer, ppoints, meterial, pscale, userdata){
			highlighterSkinClass = zcircle_highlighterSkinClass;
			shadowSkinClass = zcircle_shadowSkinClass;
			super(m_world, renderer, ppoints, meterial, pscale, userdata);
			makeShapes();
		}
		override public function makeShapes():void{
			var def:b2CircleDef;
			def = new b2CircleDef();
			def.radius = (points[1] / scale);
			def.friction = 1;
			def.density = 1;
			body.CreateShape(def);
			if (userdata.type == "sensor"){
				setAsSensor();
			};
			zSetMassFromShapes();
		}
		override public function SetSkin(shade:String=null, color=0xD2D2D2, alpha=1, pskin=null){
			skin.graphics.clear();
			switch (shade){
				case "none":
					break;
				case "solid":
					skin.graphics.beginFill(color, alpha);
					skin.graphics.drawCircle(0, 0, points[1]);
					skin.graphics.endFill();
					break;
				case "bitmap":
					if (pskin != null){
						skin.graphics.beginBitmapFill(pskin.bitmapData);
						skin.graphics.drawCircle(0, 0, points[1]);
						skin.graphics.endFill();
					};
					break;
				case "swf":
					if (pskin != null){
						skin.addChild(pskin);
						pskin.name = "skin";
						pskin.width = (pskin.height = (points[1] * 2));
					};
					if (meterial.hasHighlight){
						highlight_mc.addChild(new highlighterSkinClass());
						highlight_mc.blendMode = BlendMode.ADD;
						highlight_mc.width = (highlight_mc.height = points[1]);
						shadow_mc.addChild(new shadowSkinClass());
						shadow_mc.blendMode = BlendMode.SUBTRACT;
						shadow_mc.alpha = 0.3;
						shadow_mc.width = (shadow_mc.height = (points[1] * 2));
					};
					break;
			};
		}

	}
}//package zahid.games.game59.item.shape 
Section 182
//zcircle_highlighterSkinClass (zahid.games.game59.item.shape.zcircle_highlighterSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zcircle_highlighterSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 183
//zcircle_shadowSkinClass (zahid.games.game59.item.shape.zcircle_shadowSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zcircle_shadowSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 184
//zcustomshape (zahid.games.game59.item.shape.zcustomshape)
package zahid.games.game59.item.shape {
	import flash.geom.*;
	import zahid.games.game59.item.*;

	public class zcustomshape extends zitem {

		public function zcustomshape(m_world, renderer, ppoints:Array, pscale, userdata, meterial){
			super(m_world, renderer, ppoints, meterial, pscale, userdata);
			makeShapes();
		}
		override public function makeShapes():void{
			var tempPoints:Array = new Array();
			var i:* = 0;
			while (i < points.length) {
				tempPoints.push(new Point(((points[i].x - points[0].x) / scale), ((points[i].y - points[1].y) / scale)));
				i++;
			};
			meterial.mltDef.SetAsZShape(tempPoints);
			body.CreateShape(meterial.mltDef);
			if (userdata.type == "sensor"){
				setAsSensor();
			};
			zSetMassFromShapes();
		}
		override public function SetSkin(shade:String=null, color=0xD2D2D2, alpha=1, pskin=null){
			var i:*;
			skin.graphics.clear();
			switch (shade){
				case "none":
					break;
				case "solid":
					skin.x = points[0].x;
					skin.y = points[0].y;
					skin.graphics.beginFill(color, alpha);
					skin.graphics.moveTo(0, 0);
					i = 1;
					while (i < points.length) {
						skin.graphics.lineTo((points[i].x - points[0].x), (points[i].y - points[0].y));
						i++;
					};
					skin.graphics.endFill();
					break;
				case "bitmap":
					if (pskin != null){
						skin.x = points[0].x;
						skin.y = points[0].y;
						skin.graphics.beginBitmapFill(pskin.bitmapData);
						i = 1;
						while (i < points.length) {
							skin.graphics.lineTo((points[i].x - points[0].x), (points[i].y - points[0].y));
							i++;
						};
						skin.graphics.endFill();
					};
					break;
			};
		}

	}
}//package zahid.games.game59.item.shape 
Section 185
//zmotorBike (zahid.games.game59.item.shape.zmotorBike)
package zahid.games.game59.item.shape {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import com.roguedevelopment.pulse.particle.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import com.roguedevelopment.pulse.*;
	import General.*;
	import com.roguedevelopment.pulse.emitter.*;
	import com.gmac.sound.*;
	import flash.text.*;
	import com.roguedevelopment.pulse.rule.*;
	import com.roguedevelopment.pulse.initializers.*;
	import zahid.games.common.*;

	public class zmotorBike {

		var rl2p1;
		var rl2p2;
		var bbody;
		private var soundBooClass:Class;
		var rLeg11Skin;
		var jumpReady:Boolean;// = false
		var rHeadSkin;
		var scliecer;
		var rLeg22Skin;
		public var bikerStrength;// = 70
		var rHand22Skin;
		var handle;
		var bikeJoint:Array;
		var emitterBlood:GenericEmitter;
		var bcbody1;
		var emitterExplod:GenericEmitter;
		var wheel1;
		private var soundBreakClass:Class;
		var rl1p1;
		var rl1p2;
		var wheel2;
		var rb;
		public var controlLock:Boolean;// = false
		private var breaklightGlowSkin:Class;
		var bikeReady:Boolean;// = false
		var riderJoints:Array;
		var bikeExplod:Boolean;// = false
		var onGround:Boolean;// = false
		var bcbody2:b2Body;
		public var bikeStrength;// = 70
		var scale;
		var $soundBlast:SoundSkin;
		var m_world:b2World;
		var w1jb;
		var wheel2Skin;
		var $soundHit:SoundSkin;
		var $soundBreak:SoundSkin;
		var fallen:Boolean;// = false
		var y;
		var rider:Array;
		var bikeBodyParts:Array;
		var rh2p2;
		var x;
		var rideJoint:Array;
		var bileFallen:Boolean;// = false
		var riderSkinArray:Array;
		private var breaklightSkin:Class;
		var renderCanvas:Sprite;
		var rHand12Skin;
		var rLeg21Skin;
		var rLeg12Skin;
		var rHand21Skin;
		var rh2p1;
		var emitterSmoke:GenericEmitter;
		var $soundEngine:SoundSkin;
		public var breakVal;// = 40
		public var bikerRank;// = 50
		var breaklightGlow;
		var hitObject:Object;
		var rh1p1;
		var rh1p2;
		var bBodySkin;
		private var soundChokeClass:Class;
		var handleSkin;
		private var soundEngineClass:Class;
		private var soundBlastClass:Class;
		var rBodySkin;
		private var headlightSkin:Class;
		private var soundEngine2Class:Class;
		var $soundChoke:SoundSkin;
		var wheel1Skin;
		var lightsOn:Boolean;// = false
		var head;
		public var excelVal;// = 100
		var bikeSkinArray:Array;
		var rHand11Skin;

		public function zmotorBike(loc:b2Vec2, pm_world:b2World, renderer, pscale){
			headlightSkin = zmotorBike_headlightSkin;
			breaklightSkin = zmotorBike_breaklightSkin;
			breaklightGlowSkin = zmotorBike_breaklightGlowSkin;
			soundBreakClass = zmotorBike_soundBreakClass;
			soundBooClass = zmotorBike_soundBooClass;
			soundChokeClass = zmotorBike_soundChokeClass;
			soundEngineClass = zmotorBike_soundEngineClass;
			soundEngine2Class = zmotorBike_soundEngine2Class;
			soundBlastClass = zmotorBike_soundBlastClass;
			rideJoint = new Array();
			rider = new Array();
			riderJoints = new Array();
			bikeJoint = new Array();
			bikeBodyParts = new Array();
			bikeSkinArray = new Array();
			riderSkinArray = new Array();
			hitObject = new Object();
			$soundBreak = new SoundSkin(new soundBreakClass());
			$soundHit = new SoundSkin(new soundBooClass());
			$soundChoke = new SoundSkin(new soundChokeClass());
			$soundEngine = new SoundSkin(new soundEngineClass(), 0);
			$soundBlast = new SoundSkin(new soundBlastClass());
			super();
			hitObject.level = 0;
			hitObject.hit = false;
			renderCanvas = renderer;
			x = loc.x;
			y = loc.y;
			m_world = pm_world;
			scale = pscale;
			PulseEngine.instance.root = renderCanvas;
			$soundEngine.volume = 0.2;
		}
		public function ContactRemoveHandler(point:b2ContactPoint){
			if ((((point.shape1.GetBody().GetUserData().name == "wheel1")) || ((point.shape2.GetBody().GetUserData().name == "wheel1")))){
				onGround = false;
			};
		}
		public function standingUp(){
			return (((((bbody.GetAngle() * (180 / Math.PI)) % 360))<0.6) ? true : false);
		}
		public function ContactPersistHandler(point:b2ContactPoint){
			if ((((((point.shape1.GetBody().GetUserData().name == "wheel1")) && ((point.shape2.GetBody().GetUserData().name == "ground")))) || ((((point.shape2.GetBody().GetUserData().name == "wheel1")) && ((point.shape1.GetBody().GetUserData().name == "ground")))))){
				onGround = true;
			};
		}
		public function skin(state:Boolean){
			var item:*;
			for each (item in bikeSkinArray) {
				item.visible = state;
			};
		}
		public function IsBikeReady():Boolean{
			return (bikeReady);
		}
		public function getLinearVelocity(){
			return (new Point(rb.GetLinearVelocity().x, rb.GetLinearVelocity().y));
		}
		public function create(){
			var bodyDef:b2BodyDef = new b2BodyDef();
			bodyDef.position.Set((0 + x), (0 + y));
			var def:b2CircleDef = new b2CircleDef();
			def.radius = (15 / scale);
			def.friction = 2;
			def.density = 1;
			def.filter.categoryBits = 1;
			def.filter.groupIndex = -2;
			var boxDef:b2PolygonDef = new b2PolygonDef();
			boxDef.density = 1;
			boxDef.SetAsBox(0.1, 0.1);
			boxDef.filter.categoryBits = 1;
			boxDef.filter.groupIndex = -2;
			var userdata_fill:b2zUserData = new b2zUserData();
			var djDef:b2DistanceJointDef = new b2DistanceJointDef();
			djDef.collideConnected = false;
			var rjDef:b2RevoluteJointDef = new b2RevoluteJointDef();
			rjDef.collideConnected = false;
			var pjDef:b2PrismaticJointDef = new b2PrismaticJointDef();
			var worldAxis:b2Vec2 = new b2Vec2(-0.5, 2);
			bodyDef.isBullet = true;
			wheel1 = m_world.CreateBody(bodyDef);
			var userdata:b2zUserData = new b2zUserData("wheel1");
			wheel1.SetUserData(userdata);
			wheel1.CreateShape(def);
			wheel1.SetMassFromShapes();
			bikeBodyParts.push(wheel1);
			bodyDef.position.Set((2.5 + x), (0 + y));
			wheel2 = m_world.CreateBody(bodyDef);
			wheel2.CreateShape(def);
			wheel2.SetMassFromShapes();
			userdata = new b2zUserData("wheel2");
			wheel2.SetUserData(userdata);
			bikeBodyParts.push(wheel2);
			bodyDef.isBullet = false;
			bodyDef.position.Set((0.8 + x), (-0.3 + y));
			boxDef.SetAsBox((30 / scale), (12 / scale));
			bbody = m_world.CreateBody(bodyDef);
			userdata = new b2zUserData("bbody");
			bbody.SetUserData(userdata);
			bbody.CreateShape(boxDef);
			boxDef.SetAsOrientedBox((10 / scale), (10 / scale), new b2Vec2(-1.1, 0), 2.5);
			bbody.CreateShape(boxDef);
			bikeBodyParts.push(bbody);
			def.radius = (18 / scale);
			def.localPosition = new b2Vec2(0.75, -0.15);
			bbody.CreateShape(def);
			def.radius = (7 / scale);
			def.localPosition = new b2Vec2(1.25, -0.7);
			bbody.CreateShape(def);
			bbody.SetMassFromShapes();
			boxDef.SetAsBox((2 / scale), (2 / scale));
			bodyDef.position.Set((0 + x), (0 + y));
			w1jb = m_world.CreateBody(bodyDef);
			w1jb.CreateShape(boxDef);
			w1jb.SetMassFromShapes();
			w1jb.SetUserData(userdata_fill);
			bikeBodyParts.push(w1jb);
			bodyDef.position.Set((2.5 + x), (0 + y));
			var w2jb:b2Body = m_world.CreateBody(bodyDef);
			w2jb.CreateShape(boxDef);
			w2jb.SetMassFromShapes();
			w2jb.SetUserData(userdata_fill);
			bikeBodyParts.push(w2jb);
			bodyDef.position.Set((1.5 + x), (-1.5 + y));
			boxDef.SetAsBox((5 / scale), (5 / scale));
			handle = m_world.CreateBody(bodyDef);
			handle.CreateShape(boxDef);
			handle.SetUserData(userdata_fill);
			boxDef.SetAsOrientedBox((2 / scale), (30 / scale), new b2Vec2(0.5, 0.8), 2.5);
			handle.CreateShape(boxDef);
			handle.SetMassFromShapes();
			bikeBodyParts.push(handle);
			boxDef.SetAsBox((2 / scale), (2 / scale));
			bodyDef.position.Set((-0.2 + x), (0.1 + y));
			scliecer = m_world.CreateBody(bodyDef);
			scliecer.CreateShape(boxDef);
			scliecer.SetMassFromShapes();
			scliecer.SetUserData(userdata_fill);
			bikeBodyParts.push(scliecer);
			rjDef.Initialize(w1jb, wheel1, wheel1.GetWorldCenter());
			var wheel_w1jb_joint:* = m_world.CreateJoint(rjDef);
			bikeJoint.push(wheel_w1jb_joint);
			rjDef.Initialize(w2jb, wheel2, wheel2.GetWorldCenter());
			var wheel2_w2jb_joint:* = m_world.CreateJoint(rjDef);
			bikeJoint.push(wheel2_w2jb_joint);
			djDef.Initialize(handle, w2jb, new b2Vec2((handle.GetWorldCenter().x + 0.5), (handle.GetWorldCenter().y + 0.9)), w2jb.GetWorldCenter());
			var handle_w2jb_joint:* = m_world.CreateJoint(djDef);
			bikeJoint.push(handle_w2jb_joint);
			rjDef.lowerAngle = 0;
			rjDef.upperAngle = 0;
			rjDef.enableLimit = true;
			rjDef.Initialize(w1jb, bbody, w1jb.GetWorldCenter());
			var bbody_w1jb_joint:* = m_world.CreateJoint(rjDef);
			bikeJoint.push(bbody_w1jb_joint);
			djDef.Initialize(w1jb, w2jb, w1jb.GetWorldCenter(), w2jb.GetWorldCenter());
			var w1jb_w2jb_joint:* = m_world.CreateJoint(djDef);
			bikeJoint.push(w1jb_w2jb_joint);
			rjDef.Initialize(bbody, handle, new b2Vec2((bbody.GetWorldCenter().x + 0.7), (bbody.GetWorldCenter().y - 0.2)));
			var bbody_handle_joint:* = m_world.CreateJoint(rjDef);
			bikeJoint.push(bbody_handle_joint);
			rjDef.Initialize(bbody, w2jb, w2jb.GetWorldCenter());
			var bbody_w2jb_joint:* = m_world.CreateJoint(rjDef);
			bikeJoint.push(bbody_w2jb_joint);
			djDef.Initialize(w1jb, handle, w1jb.GetWorldCenter(), new b2Vec2((handle.GetWorldCenter().x - 0.1), (handle.GetWorldCenter().y + 0.1)));
			var handle_w1jb_joint:* = m_world.CreateJoint(djDef);
			bikeJoint.push(handle_w1jb_joint);
			rjDef.Initialize(bbody, scliecer, scliecer.GetWorldCenter());
			var bbody_scliecer_joint:* = m_world.CreateJoint(rjDef);
			bikeJoint.push(bbody_scliecer_joint);
			bodyDef.position.Set((0.2 + x), (-1.2 + y));
			boxDef.SetAsBox((5 / scale), (15 / scale));
			rb = m_world.CreateBody(bodyDef);
			rb.CreateShape(boxDef);
			rb.SetMassFromShapes();
			rb.SetUserData(userdata_fill);
			rider.push(rb);
			bodyDef.position.Set((0.7 + x), (-0.8 + y));
			boxDef.SetAsOrientedBox((15 / scale), (4 / scale), new b2Vec2(0, 0), -0.1);
			rl1p1 = m_world.CreateBody(bodyDef);
			rl1p1.CreateShape(boxDef);
			rl1p1.SetMassFromShapes();
			rl1p1.SetUserData(userdata_fill);
			rider.push(rl1p1);
			bodyDef.position.Set((1.2 + x), (-0.4 + y));
			boxDef.SetAsOrientedBox((4 / scale), (15 / scale), new b2Vec2(0, 0), -0.1);
			rl1p2 = m_world.CreateBody(bodyDef);
			rl1p2.CreateShape(boxDef);
			rl1p2.SetMassFromShapes();
			rl1p2.SetUserData(userdata_fill);
			rider.push(rl1p2);
			bodyDef.position.Set((0.7 + x), (-0.8 + y));
			boxDef.SetAsOrientedBox((15 / scale), (4 / scale), new b2Vec2(0, 0), -0.1);
			rl2p1 = m_world.CreateBody(bodyDef);
			rl2p1.CreateShape(boxDef);
			rl2p1.SetMassFromShapes();
			rl2p1.SetUserData(userdata_fill);
			rider.push(rl2p1);
			bodyDef.position.Set((1.2 + x), (-0.4 + y));
			boxDef.SetAsOrientedBox((4 / scale), (15 / scale), new b2Vec2(0, 0), -0.1);
			rl2p2 = m_world.CreateBody(bodyDef);
			rl2p2.CreateShape(boxDef);
			rl2p2.SetMassFromShapes();
			rl2p2.SetUserData(userdata_fill);
			rider.push(rl2p2);
			bodyDef.position.Set((0.4 + x), (-1.4 + y));
			boxDef.SetAsOrientedBox((3 / scale), (10 / scale), new b2Vec2(0, 0), -1.2);
			rh1p1 = m_world.CreateBody(bodyDef);
			rh1p1.CreateShape(boxDef);
			rh1p1.SetMassFromShapes();
			rh1p1.SetUserData(userdata_fill);
			rider.push(rh1p1);
			bodyDef.position.Set((1 + x), (-1.4 + y));
			boxDef.SetAsOrientedBox((3 / scale), (12 / scale), new b2Vec2(0, 0), 1.2);
			rh1p2 = m_world.CreateBody(bodyDef);
			rh1p2.CreateShape(boxDef);
			rh1p2.SetMassFromShapes();
			rh1p2.SetUserData(userdata_fill);
			rider.push(rh1p2);
			bodyDef.position.Set((0.4 + x), (-1.4 + y));
			boxDef.SetAsOrientedBox((3 / scale), (10 / scale), new b2Vec2(0, 0), -1.2);
			rh2p1 = m_world.CreateBody(bodyDef);
			rh2p1.CreateShape(boxDef);
			rh2p1.SetMassFromShapes();
			rh2p1.SetUserData(userdata_fill);
			rider.push(rh2p1);
			bodyDef.position.Set((1 + x), (-1.4 + y));
			boxDef.SetAsOrientedBox((3 / scale), (12 / scale), new b2Vec2(0, 0), 1.2);
			rh2p2 = m_world.CreateBody(bodyDef);
			rh2p2.CreateShape(boxDef);
			rh2p2.SetMassFromShapes();
			rh2p2.SetUserData(userdata_fill);
			rider.push(rh2p2);
			bodyDef.position.Set((0.3 + x), (-1.8 + y));
			boxDef.SetAsOrientedBox((8 / scale), (5 / scale), new b2Vec2(0, 0), 1.5);
			head = m_world.CreateBody(bodyDef);
			head.CreateShape(boxDef);
			head.SetMassFromShapes();
			userdata = new b2zUserData("head");
			head.SetUserData(userdata);
			rider.push(head);
			rjDef.lowerAngle = -0.6;
			rjDef.upperAngle = 1.5;
			rjDef.enableLimit = true;
			rjDef.Initialize(rb, rl1p1, new b2Vec2((0.2 + x), (-0.7 + y)));
			var rb_rl1p1_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rb_rl1p1_joint);
			rjDef.Initialize(rb, rl2p1, new b2Vec2((0.2 + x), (-0.7 + y)));
			var rb_rl2p1_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rb_rl2p1_joint);
			rjDef.lowerAngle = -0.9;
			rjDef.upperAngle = (0.4 * b2Settings.b2_pi);
			rjDef.enableLimit = true;
			rjDef.Initialize(rl1p1, rl1p2, new b2Vec2((1.15 + x), (-0.8 + y)));
			var rl1p1_rl1p2_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rl1p1_rl1p2_joint);
			rjDef.Initialize(rl2p1, rl2p2, new b2Vec2((1.15 + x), (-0.8 + y)));
			var rl2p1_rl2p2_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rl2p1_rl2p2_joint);
			rjDef.lowerAngle = (-0.5 * b2Settings.b2_pi);
			rjDef.upperAngle = (0.8 * b2Settings.b2_pi);
			rjDef.Initialize(rb, rh1p1, new b2Vec2((0.2 + x), (-1.5 + y)));
			var rh1p1_rbp3_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rh1p1_rbp3_joint);
			rjDef.Initialize(rb, rh2p1, new b2Vec2((0.2 + x), (-1.5 + y)));
			var rh2p1_rbp3_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rh2p1_rbp3_joint);
			rjDef.lowerAngle = (-0.8 * b2Settings.b2_pi);
			rjDef.upperAngle = 0;
			rjDef.Initialize(rh1p1, rh1p2, new b2Vec2((0.7 + x), (-1.3 + y)));
			var rh1p1_rh1p2_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rh1p1_rh1p2_joint);
			rjDef.Initialize(rh2p1, rh2p2, new b2Vec2((0.7 + x), (-1.3 + y)));
			var rh2p1_rh2p2_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rh2p1_rh2p2_joint);
			rjDef.lowerAngle = -0.2;
			rjDef.upperAngle = 0.4;
			rjDef.Initialize(head, rb, new b2Vec2((0.2 + x), (-1.6 + y)));
			var rb_head_joint:* = m_world.CreateJoint(rjDef);
			riderJoints.push(rb_head_joint);
			rjDef.Initialize(bbody, rb, bbody.GetWorldCenter());
			var seat_rb_joint:* = m_world.CreateJoint(rjDef);
			rideJoint.push(seat_rb_joint);
			rjDef.Initialize(bbody, rl1p2, bbody.GetWorldCenter());
			var bbody1_rl1p2_joint:* = m_world.CreateJoint(rjDef);
			rideJoint.push(bbody1_rl1p2_joint);
			rjDef.Initialize(bbody, rl2p2, bbody.GetWorldCenter());
			var bbody_rl2p2_joint:* = m_world.CreateJoint(rjDef);
			rideJoint.push(bbody_rl2p2_joint);
			rjDef.Initialize(handle, rh1p2, handle.GetWorldCenter());
			var handle_rh1p2_joint:* = m_world.CreateJoint(rjDef);
			rideJoint.push(handle_rh1p2_joint);
			rjDef.Initialize(handle, rh2p2, handle.GetWorldCenter());
			var handle_rh2p2_joint:* = m_world.CreateJoint(rjDef);
			rideJoint.push(handle_rh2p2_joint);
		}
		public function getCenter(){
			return (new Point((rb.GetWorldCenter().x * scale), (rb.GetWorldCenter().y * scale)));
		}
		public function makeSmoke(){
			var rules:Array = [];
			rules.push(new MovementRule());
			rules.push(new DeathRule(1000));
			rules.push(new FadeRule(900));
			rules.push(new GravityRule(-2));
			rules.push(new ScaleRule(1000, 1, 2));
			var initializers:Array = [];
			initializers.push(new ParameterRandomizerInitializer("speed", 0, 100, true));
			initializers.push(new AngleRandomizerInitializer(216, 180));
			var particleSmokeFactory:* = new GenericFactory(DotSmokeParticle, rules, initializers);
			emitterSmoke = new GenericEmitter(1000);
			emitterSmoke.setFactory(particleSmokeFactory);
			emitterSmoke.start();
		}
		public function IsFallen():Boolean{
			return (fallen);
		}
		public function ContactResultHandler(point:b2ContactResult){
			if ((((point.shape1.GetBody().GetUserData().name == "wheel2")) || ((point.shape2.GetBody().GetUserData().name == "wheel2")))){
				if (point.normalImpulse > bikeStrength){
					hitObject.hit = true;
					hitObject.level = 2;
				};
				if ((((point.normalImpulse > bikerRank)) && ((point.normal.x < -0.5)))){
					hitObject.hit = true;
					hitObject.level = 1;
				};
			};
			if (((!((point.shape1.GetBody().GetUserData().type == "sensor"))) || (!(!((point.shape2.GetBody().GetUserData().type == "sensor")))))){
				if ((((((point.shape1.GetBody().GetUserData().name == "head")) || ((point.shape2.GetBody().GetUserData().name == "head")))) && ((point.normalImpulse > 10)))){
					emitterBlood.particleLimit = (point.normalImpulse * 5);
					emitterBlood.start();
					if (Main.gamesound){
						$soundChoke.play();
					} else {
						$soundChoke.stop();
					};
				};
			};
		}
		public function setEngineVolume(val){
			$soundEngine.volume = val;
		}
		public function bleedReady(){
			var rules:Array = [];
			rules.push(new MovementRule());
			rules.push(new DeathRule(1000));
			rules.push(new FadeRule(1000));
			rules.push(new GravityRule(20));
			rules.push(new ScaleRule(100, 0.2, 0.5));
			var initializers:Array = [];
			initializers.push(new ParameterRandomizerInitializer("speed", 15, 40, true));
			initializers.push(new AngleRandomizerInitializer(0, 360));
			var particleSmokeFactory:* = new GenericFactory(DotBloodParticle, rules, initializers);
			emitterBlood = new GenericEmitter(5000);
			emitterBlood.particleLimit = 500;
			emitterBlood.setFactory(particleSmokeFactory);
			emitterBlood.stop();
		}
		public function getSpeed(){
			return (bbody.GetLinearVelocity().x);
		}
		public function remove(){
			var item:*;
			$soundEngine.stop();
			emitterExplod.stop();
			emitterExplod = null;
			emitterSmoke.stop();
			emitterSmoke = null;
			emitterBlood.stop();
			emitterBlood = null;
			for each (item in bikeSkinArray) {
				renderCanvas.removeChild(item);
				item = null;
			};
			bikeSkinArray = new Array();
			for each (item in riderSkinArray) {
				renderCanvas.removeChild(item);
				item = null;
			};
			riderSkinArray = new Array();
			for each (item in bikeJoint) {
				m_world.DestroyJoint(item);
				item = null;
			};
			bikeJoint = new Array();
			for each (item in riderJoints) {
				m_world.DestroyJoint(item);
				item = null;
			};
			riderJoints = new Array();
			for each (item in rideJoint) {
				m_world.DestroyJoint(item);
				item = null;
			};
			rideJoint = new Array();
			for each (item in bikeBodyParts) {
				m_world.DestroyBody(item);
				item = null;
			};
			bikeBodyParts = new Array();
			for each (item in rider) {
				m_world.DestroyBody(item);
				item = null;
			};
			rider = new Array();
		}
		public function hit(){
			var item:*;
			onGround = false;
			switch (hitObject.level){
				case 2:
					for each (item in bikeJoint) {
						m_world.DestroyJoint(item);
						item = null;
					};
					bikeJoint = new Array();
					$soundEngine.stop();
					if (Main.gamesound){
						$soundBlast.play();
						//unresolved jump
					};
					emitterExplod.start();
					bikeExplod = true;
				case 1:
					for each (item in rideJoint) {
						m_world.DestroyJoint(item);
						item = null;
					};
					rideJoint = new Array();
				default:
					if (((!(fallen)) && (Main.gamesound))){
						$soundHit.play();
						//unresolved jump
					};
			};
			for each (item in rider) {
				item.SetAngularVelocity((25 * Math.random()));
				item.ApplyImpulse(new b2Vec2((3 * Math.random()), (3 * Math.random())), item.GetWorldCenter());
			};
			fallen = true;
			hitObject.hit = false;
			hitObject.level = 0;
		}
		public function ContactAddHandler(point:b2ContactPoint){
			if (((!((point.shape1.GetBody().GetUserData().type == "sensor"))) || (!(!((point.shape2.GetBody().GetUserData().type == "sensor")))))){
				if ((((((point.shape1.GetBody().GetUserData().name == "head")) || ((point.shape2.GetBody().GetUserData().name == "head")))) && (!(fallen)))){
					hitObject.hit = true;
					hitObject.level = 1;
				};
			};
		}
		function skinUpdate(){
			wheel1Skin.x = (wheel1.GetPosition().x * scale);
			wheel1Skin.y = (wheel1.GetPosition().y * scale);
			wheel1Skin.tire_mc.rotation = ((wheel1.GetAngle() * (180 / Math.PI)) % 360);
			wheel2Skin.x = (wheel2.GetPosition().x * scale);
			wheel2Skin.y = (wheel2.GetPosition().y * scale);
			wheel2Skin.tire_mc.rotation = ((wheel2.GetAngle() * (180 / Math.PI)) % 360);
			bBodySkin.x = (bbody.GetPosition().x * scale);
			bBodySkin.y = (bbody.GetPosition().y * scale);
			bBodySkin.rotation = ((bbody.GetAngle() * (180 / Math.PI)) % 360);
			handleSkin.x = (handle.GetPosition().x * scale);
			handleSkin.y = (handle.GetPosition().y * scale);
			handleSkin.rotation = ((handle.GetAngle() * (180 / Math.PI)) % 360);
			bBodySkin.mask1_mc.rotation = (bBodySkin.mask2_mc.rotation = (bBodySkin.mask3_mc.rotation = (-(bbody.GetAngle()) * 57.2958)));
			handleSkin.mask_mc.rotation = (-((handle.GetAngle() * (180 / Math.PI))) % 360);
			rLeg11Skin.x = (rl1p1.GetPosition().x * scale);
			rLeg11Skin.y = (rl1p1.GetPosition().y * scale);
			rLeg11Skin.rotation = ((rl1p1.GetAngle() * (180 / Math.PI)) % 360);
			rLeg12Skin.x = (rl1p2.GetPosition().x * scale);
			rLeg12Skin.y = (rl1p2.GetPosition().y * scale);
			rLeg12Skin.rotation = ((rl1p2.GetAngle() * (180 / Math.PI)) % 360);
			rBodySkin.x = (rb.GetPosition().x * scale);
			rBodySkin.y = (rb.GetPosition().y * scale);
			rBodySkin.rotation = ((rb.GetAngle() * (180 / Math.PI)) % 360);
			rHeadSkin.x = (head.GetPosition().x * scale);
			rHeadSkin.y = (head.GetPosition().y * scale);
			rHeadSkin.rotation = ((head.GetAngle() * (180 / Math.PI)) % 360);
			rLeg21Skin.x = (rl2p1.GetPosition().x * scale);
			rLeg21Skin.y = (rl2p1.GetPosition().y * scale);
			rLeg21Skin.rotation = ((rl2p1.GetAngle() * (180 / Math.PI)) % 360);
			rLeg22Skin.x = (rl2p2.GetPosition().x * scale);
			rLeg22Skin.y = (rl2p2.GetPosition().y * scale);
			rLeg22Skin.rotation = ((rl2p2.GetAngle() * (180 / Math.PI)) % 360);
			rHand11Skin.x = (rh1p1.GetPosition().x * scale);
			rHand11Skin.y = (rh1p1.GetPosition().y * scale);
			rHand11Skin.rotation = ((rh1p1.GetAngle() * (180 / Math.PI)) % 360);
			rHand12Skin.x = (rh1p2.GetPosition().x * scale);
			rHand12Skin.y = (rh1p2.GetPosition().y * scale);
			rHand12Skin.rotation = ((rh1p2.GetAngle() * (180 / Math.PI)) % 360);
			rHand21Skin.x = (rh2p1.GetPosition().x * scale);
			rHand21Skin.y = (rh2p1.GetPosition().y * scale);
			rHand21Skin.rotation = ((rh2p1.GetAngle() * (180 / Math.PI)) % 360);
			rHand22Skin.x = (rh2p2.GetPosition().x * scale);
			rHand22Skin.y = (rh2p2.GetPosition().y * scale);
			rHand22Skin.rotation = ((rh2p2.GetAngle() * (180 / Math.PI)) % 360);
		}
		public function update(){
			var volume:*;
			if (((!(bikeExplod)) && (Main.gamesound))){
				$soundEngine.play();
			} else {
				$soundEngine.stop();
			};
			if (IsBikeReady()){
				volume = bbody.GetLinearVelocity().x;
				if (volume > 100){
					volume = 1;
				} else {
					volume = ((volume / 100) + 0.2);
				};
				$soundEngine.volume = volume;
				emitterSmoke.x = (scliecer.GetPosition().x * scale);
				emitterSmoke.y = (scliecer.GetPosition().y * scale);
				emitterBlood.x = rHeadSkin.x;
				emitterBlood.y = rHeadSkin.y;
				emitterExplod.x = (bbody.GetPosition().x * scale);
				emitterExplod.y = ((bbody.GetPosition().y * scale) - 20);
				if (((!(fallen)) && (!(controlLock)))){
					if (Input.isKeyPressed(37)){
						bbody.ApplyImpulse(new b2Vec2(-0.1, -10), new b2Vec2((bbody.GetWorldCenter().x + 1), bbody.GetWorldCenter().y));
					};
					if (Input.isKeyPressed(39)){
						bbody.ApplyImpulse(new b2Vec2(0.1, 10), new b2Vec2((bbody.GetWorldCenter().x + 1), bbody.GetWorldCenter().y));
					};
					if (Input.isKeyReleased(17)){
						wheel1.m_linearDamping = 0;
						if (lightsOn){
							breaklightGlow.visible = false;
							//unresolved jump
						};
						if ((($soundBreak.playing) && (Main.gamesound))){
							$soundBreak.stop();
							//unresolved jump
						};
						$soundBreak.rewind();
					};
					if (((Input.isKeyReleased(32)) && (jumpReady))){
						bbody.ApplyImpulse(new b2Vec2(1, -(bikerStrength)), new b2Vec2((bbody.GetWorldCenter().x + 0.2), bbody.GetWorldCenter().y));
						jumpReady = false;
					};
					if (Input.isKeyDown(17)){
						if (Math.abs(bbody.GetAngle()) < 0.2){
							rb.SetXForm(rb.GetWorldCenter(), 0.3);
						};
					};
					if (Input.isKeyDown(32)){
						if (Math.abs(bbody.GetAngle()) < 0.6){
							rb.SetXForm(new b2Vec2((rb.GetWorldCenter().x + 0.2), (rb.GetWorldCenter().y + 0.1)), 1);
							rh1p1.SetXForm(new b2Vec2((rh1p1.GetWorldCenter().x + 0.2), (rh1p1.GetWorldCenter().y + 0.1)), 1.5);
							rh2p1.SetXForm(new b2Vec2((rh2p1.GetWorldCenter().x + 0.2), (rh2p1.GetWorldCenter().y + 0.1)), 1.5);
							head.SetXForm(new b2Vec2((head.GetWorldCenter().x + 0.2), (head.GetWorldCenter().y + 0.1)), 1.5);
						};
					};
					if (onGround){
						if (Input.isKeyDown(38)){
							if ((wheel1.GetAngularVelocity() < 80)){
								wheel1.ApplyTorque(excelVal);
								//unresolved jump
							};
						};
						if (Input.isKeyPressed(38)){
						};
						if (Input.isKeyReleased(38)){
						};
						if (Input.isKeyDown(40)){
							bbody.ApplyImpulse(new b2Vec2(-1, 0), bbody.GetWorldCenter());
							rHeadSkin.gotoAndStop(2);
						};
						if (Input.isKeyReleased(40)){
							rHeadSkin.gotoAndStop(1);
						};
						if (Input.isKeyDown(32)){
							jumpReady = true;
						};
						if (Input.isKeyDown(17)){
							wheel1.SetXForm(wheel1.GetWorldCenter(), 0);
							forceBreak();
							if (Main.gamesound){
								volume = bbody.GetLinearVelocity().x;
								if (volume > 100){
									volume = 1;
								} else {
									volume = (volume / 100);
								};
								$soundBreak.volume = volume;
								$soundBreak.play();
							};
						};
					} else {
						wheel1.m_linearDamping = 0;
					};
				};
				skinUpdate();
				if (((hitObject.hit) && (!(m_world.m_lock)))){
					hit();
					//unresolved jump
				};
			};
		}
		public function IsDead():Boolean{
			return (head.IsSleeping());
		}
		public function forceBreak(){
			wheel1.m_linearDamping = breakVal;
			if (lightsOn){
				breaklightGlow.visible = true;
				//unresolved jump
			};
		}
		public function ExplodReady(){
			var rules:Array = [];
			rules.push(new MovementRule());
			rules.push(new DeathRule(1000));
			rules.push(new GravityRule(-5));
			rules.push(new FadeRule(900));
			rules.push(new ScaleRule(100, 0.2, 1.5));
			var initializers:Array = [];
			initializers.push(new ParameterRandomizerInitializer("speed", 10, 55, true));
			initializers.push(new AngleRandomizerInitializer(0, 360));
			var particleSmokeFactory:* = new GenericFactory(DotExplodeParticle, rules, initializers);
			emitterExplod = new GenericEmitter(5000);
			emitterExplod.particleLimit = 500;
			emitterExplod.setFactory(particleSmokeFactory);
			emitterExplod.stop();
		}
		public function skined(){
		}
		public function attacheLights(){
			var headlight:* = new headlightSkin();
			var breaklight:* = new breaklightSkin();
			breaklightGlow = new breaklightGlowSkin();
			bBodySkin.addChild(headlight);
			bBodySkin.addChild(breaklightGlow);
			bBodySkin.addChild(breaklight);
			headlight.blendMode = BlendMode.ADD;
			breaklightGlow.blendMode = BlendMode.ADD;
			breaklightGlow.visible = false;
			lightsOn = true;
		}

	}
}//package zahid.games.game59.item.shape 
Section 186
//zmotorBike_breaklightGlowSkin (zahid.games.game59.item.shape.zmotorBike_breaklightGlowSkin)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_breaklightGlowSkin extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 187
//zmotorBike_breaklightSkin (zahid.games.game59.item.shape.zmotorBike_breaklightSkin)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_breaklightSkin extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 188
//zmotorBike_headlightSkin (zahid.games.game59.item.shape.zmotorBike_headlightSkin)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_headlightSkin extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 189
//zmotorBike_soundBlastClass (zahid.games.game59.item.shape.zmotorBike_soundBlastClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_soundBlastClass extends SoundAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 190
//zmotorBike_soundBooClass (zahid.games.game59.item.shape.zmotorBike_soundBooClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_soundBooClass extends SoundAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 191
//zmotorBike_soundBreakClass (zahid.games.game59.item.shape.zmotorBike_soundBreakClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_soundBreakClass extends SoundAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 192
//zmotorBike_soundChokeClass (zahid.games.game59.item.shape.zmotorBike_soundChokeClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_soundChokeClass extends SoundAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 193
//zmotorBike_soundEngine2Class (zahid.games.game59.item.shape.zmotorBike_soundEngine2Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_soundEngine2Class extends SoundAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 194
//zmotorBike_soundEngineClass (zahid.games.game59.item.shape.zmotorBike_soundEngineClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike_soundEngineClass extends SoundAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 195
//zmotorBike1 (zahid.games.game59.item.shape.zmotorBike1)
package zahid.games.game59.item.shape {

	public class zmotorBike1 extends zmotorBike {

		private var wheelSkinClass:Class;
		private var rhp1Class:Class;
		private var rBodySkinClass:Class;
		private var rhp2Class:Class;
		private var rHeadSkinClass:Class;
		private var bHandleSkinClass:Class;
		private var bBodySkinClass:Class;
		private var rlp2Class:Class;
		private var rlp1Class:Class;

		public function zmotorBike1(loc, pm_world, renderer, pscale){
			wheelSkinClass = zmotorBike1_wheelSkinClass;
			bBodySkinClass = zmotorBike1_bBodySkinClass;
			bHandleSkinClass = zmotorBike1_bHandleSkinClass;
			rBodySkinClass = zmotorBike1_rBodySkinClass;
			rlp1Class = zmotorBike1_rlp1Class;
			rlp2Class = zmotorBike1_rlp2Class;
			rhp1Class = zmotorBike1_rhp1Class;
			rhp2Class = zmotorBike1_rhp2Class;
			rHeadSkinClass = zmotorBike1_rHeadSkinClass;
			super(loc, pm_world, renderer, pscale);
			skined();
			makeSmoke();
			bleedReady();
			ExplodReady();
		}
		override public function skined(){
			wheel1Skin = new wheelSkinClass();
			renderCanvas.addChild(wheel1Skin);
			bikeSkinArray.push(wheel1Skin);
			wheel1Skin.cacheAsBitmap = true;
			wheel2Skin = new wheelSkinClass();
			wheel2Skin.cacheAsBitmap = true;
			renderCanvas.addChild(wheel2Skin);
			bikeSkinArray.push(wheel2Skin);
			wheel1Skin.width = (wheel1Skin.height = (wheel2Skin.width = (wheel2Skin.height = 32)));
			handleSkin = new bHandleSkinClass();
			handleSkin.cacheAsBitmap = true;
			renderCanvas.addChild(handleSkin);
			bikeSkinArray.push(handleSkin);
			bBodySkin = new bBodySkinClass();
			bBodySkin.cacheAsBitmap = true;
			renderCanvas.addChild(bBodySkin);
			bikeSkinArray.push(bBodySkin);
			rLeg11Skin = new rlp1Class();
			rLeg11Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg11Skin);
			riderSkinArray.push(rLeg11Skin);
			rLeg12Skin = new rlp2Class();
			rLeg12Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg12Skin);
			riderSkinArray.push(rLeg12Skin);
			rLeg21Skin = new rlp1Class();
			rLeg21Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg21Skin);
			riderSkinArray.push(rLeg21Skin);
			rLeg22Skin = new rlp2Class();
			rLeg22Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg22Skin);
			riderSkinArray.push(rLeg22Skin);
			rHand21Skin = new rhp1Class();
			rHand21Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand21Skin);
			riderSkinArray.push(rHand21Skin);
			rHand22Skin = new rhp2Class();
			rHand22Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand22Skin);
			riderSkinArray.push(rHand22Skin);
			rHeadSkin = new rHeadSkinClass();
			rHeadSkin.cacheAsBitmap = true;
			rHeadSkin.gotoAndStop(1);
			renderCanvas.addChild(rHeadSkin);
			riderSkinArray.push(rHeadSkin);
			rBodySkin = new rBodySkinClass();
			rBodySkin.cacheAsBitmap = true;
			renderCanvas.addChild(rBodySkin);
			riderSkinArray.push(rBodySkin);
			rHand11Skin = new rhp1Class();
			rHand11Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand11Skin);
			riderSkinArray.push(rHand11Skin);
			rHand12Skin = new rhp2Class();
			rHand12Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand12Skin);
			riderSkinArray.push(rHand12Skin);
			bikeReady = true;
		}

	}
}//package zahid.games.game59.item.shape 
Section 196
//zmotorBike1_bBodySkinClass (zahid.games.game59.item.shape.zmotorBike1_bBodySkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_bBodySkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var mask1_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 197
//zmotorBike1_bHandleSkinClass (zahid.games.game59.item.shape.zmotorBike1_bHandleSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_bHandleSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 198
//zmotorBike1_rBodySkinClass (zahid.games.game59.item.shape.zmotorBike1_rBodySkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_rBodySkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var mask1_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 199
//zmotorBike1_rHeadSkinClass (zahid.games.game59.item.shape.zmotorBike1_rHeadSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_rHeadSkinClass extends MovieClipAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 200
//zmotorBike1_rhp1Class (zahid.games.game59.item.shape.zmotorBike1_rhp1Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_rhp1Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var mask1_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 201
//zmotorBike1_rhp2Class (zahid.games.game59.item.shape.zmotorBike1_rhp2Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_rhp2Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 202
//zmotorBike1_rlp1Class (zahid.games.game59.item.shape.zmotorBike1_rlp1Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_rlp1Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 203
//zmotorBike1_rlp2Class (zahid.games.game59.item.shape.zmotorBike1_rlp2Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_rlp2Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 204
//zmotorBike1_wheelSkinClass (zahid.games.game59.item.shape.zmotorBike1_wheelSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike1_wheelSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 205
//zmotorBike2 (zahid.games.game59.item.shape.zmotorBike2)
package zahid.games.game59.item.shape {

	public class zmotorBike2 extends zmotorBike {

		private var wheelSkinClass:Class;
		private var rhp1Class:Class;
		private var rBodySkinClass:Class;
		private var rhp2Class:Class;
		private var rHeadSkinClass:Class;
		private var bHandleSkinClass:Class;
		private var bBodySkinClass:Class;
		private var rlp2Class:Class;
		private var rlp1Class:Class;

		public function zmotorBike2(loc, pm_world, renderer, pscale){
			wheelSkinClass = zmotorBike2_wheelSkinClass;
			bBodySkinClass = zmotorBike2_bBodySkinClass;
			bHandleSkinClass = zmotorBike2_bHandleSkinClass;
			rBodySkinClass = zmotorBike2_rBodySkinClass;
			rlp1Class = zmotorBike2_rlp1Class;
			rlp2Class = zmotorBike2_rlp2Class;
			rhp1Class = zmotorBike2_rhp1Class;
			rhp2Class = zmotorBike2_rhp2Class;
			rHeadSkinClass = zmotorBike2_rHeadSkinClass;
			super(loc, pm_world, renderer, pscale);
			skined();
			makeSmoke();
			bleedReady();
			ExplodReady();
		}
		override public function skined(){
			wheel1Skin = new wheelSkinClass();
			renderCanvas.addChild(wheel1Skin);
			bikeSkinArray.push(wheel1Skin);
			wheel1Skin.cacheAsBitmap = true;
			wheel2Skin = new wheelSkinClass();
			wheel2Skin.cacheAsBitmap = true;
			renderCanvas.addChild(wheel2Skin);
			bikeSkinArray.push(wheel2Skin);
			wheel1Skin.width = (wheel1Skin.height = (wheel2Skin.width = (wheel2Skin.height = 32)));
			handleSkin = new bHandleSkinClass();
			handleSkin.cacheAsBitmap = true;
			renderCanvas.addChild(handleSkin);
			bikeSkinArray.push(handleSkin);
			bBodySkin = new bBodySkinClass();
			bBodySkin.cacheAsBitmap = true;
			renderCanvas.addChild(bBodySkin);
			bikeSkinArray.push(bBodySkin);
			rLeg11Skin = new rlp1Class();
			rLeg11Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg11Skin);
			bikeSkinArray.push(rLeg11Skin);
			rLeg12Skin = new rlp2Class();
			rLeg12Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg12Skin);
			bikeSkinArray.push(rLeg12Skin);
			rLeg21Skin = new rlp1Class();
			rLeg21Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg21Skin);
			bikeSkinArray.push(rLeg21Skin);
			rLeg22Skin = new rlp2Class();
			rLeg22Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rLeg22Skin);
			bikeSkinArray.push(rLeg22Skin);
			rHand21Skin = new rhp1Class();
			rHand21Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand21Skin);
			bikeSkinArray.push(rHand21Skin);
			rHand22Skin = new rhp2Class();
			rHand22Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand22Skin);
			bikeSkinArray.push(rHand22Skin);
			rHeadSkin = new rHeadSkinClass();
			rHeadSkin.cacheAsBitmap = true;
			rHeadSkin.gotoAndStop(1);
			renderCanvas.addChild(rHeadSkin);
			bikeSkinArray.push(rHeadSkin);
			rBodySkin = new rBodySkinClass();
			rBodySkin.cacheAsBitmap = true;
			renderCanvas.addChild(rBodySkin);
			bikeSkinArray.push(rBodySkin);
			rHand11Skin = new rhp1Class();
			rHand11Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand11Skin);
			bikeSkinArray.push(rHand11Skin);
			rHand12Skin = new rhp2Class();
			rHand12Skin.cacheAsBitmap = true;
			renderCanvas.addChild(rHand12Skin);
			bikeSkinArray.push(rHand12Skin);
			attacheLights();
			bikeReady = true;
		}

	}
}//package zahid.games.game59.item.shape 
Section 206
//zmotorBike2_bBodySkinClass (zahid.games.game59.item.shape.zmotorBike2_bBodySkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_bBodySkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 207
//zmotorBike2_bHandleSkinClass (zahid.games.game59.item.shape.zmotorBike2_bHandleSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_bHandleSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 208
//zmotorBike2_rBodySkinClass (zahid.games.game59.item.shape.zmotorBike2_rBodySkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_rBodySkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 209
//zmotorBike2_rHeadSkinClass (zahid.games.game59.item.shape.zmotorBike2_rHeadSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_rHeadSkinClass extends MovieClipAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 210
//zmotorBike2_rhp1Class (zahid.games.game59.item.shape.zmotorBike2_rhp1Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_rhp1Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 211
//zmotorBike2_rhp2Class (zahid.games.game59.item.shape.zmotorBike2_rhp2Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_rhp2Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 212
//zmotorBike2_rlp1Class (zahid.games.game59.item.shape.zmotorBike2_rlp1Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_rlp1Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 213
//zmotorBike2_rlp2Class (zahid.games.game59.item.shape.zmotorBike2_rlp2Class)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_rlp2Class extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 214
//zmotorBike2_wheelSkinClass (zahid.games.game59.item.shape.zmotorBike2_wheelSkinClass)
package zahid.games.game59.item.shape {
	import flash.display.*;
	import mx.core.*;

	public class zmotorBike2_wheelSkinClass extends SpriteAsset {

		public var smoke_mc:DisplayObject;
		public var text_mc:DisplayObject;
		public var mask_mc:DisplayObject;
		public var tire_mc:DisplayObject;
		public var mask3_mc:DisplayObject;
		public var mask2_mc:DisplayObject;
		public var txt:DisplayObject;
		public var elements:DisplayObject;
		public var mask1_mc:DisplayObject;

	}
}//package zahid.games.game59.item.shape 
Section 215
//zitem (zahid.games.game59.item.zitem)
package zahid.games.game59.item {
	import Box2D.Dynamics.*;
	import flash.display.*;
	import Box2D.Collision.Shapes.*;

	public class zitem {

		public var m_world:b2World;
		public var highlight_mc;
		public var bodyDef:b2BodyDef;
		public var scale;
		public var renderer;
		public var shadow_mc;
		public var body:b2Body;
		public var points:Array;
		public var meterial;
		public var userdata;
		public var skin:Sprite;

		public function zitem(pm_world, prenderer:Sprite, ppoints:Array, pmeterial, pscale, puserdata){
			bodyDef = new b2BodyDef();
			skin = new Sprite();
			highlight_mc = new Sprite();
			shadow_mc = new Sprite();
			points = new Array();
			super();
			userdata = puserdata;
			scale = pscale;
			points = ppoints;
			meterial = pmeterial;
			bodyDef.position.Set((points[0].x / scale), (points[0].y / scale));
			renderer = prenderer;
			m_world = pm_world;
			body = m_world.CreateBody(bodyDef);
			body.SetUserData(userdata);
			renderer.addChild(skin);
			renderer.addChild(shadow_mc);
			renderer.addChild(highlight_mc);
		}
		public function setAsSensor(){
			var s:b2Shape = body.GetShapeList();
			while (s) {
				s.m_isSensor = true;
				s = s.GetNext();
			};
		}
		public function makeShapes():void{
		}
		public function _delete(){
			renderer.removeChild(skin);
			renderer.removeChild(shadow_mc);
			renderer.removeChild(highlight_mc);
			skin = null;
			m_world.DestroyBody(body);
			body = null;
		}
		public function sync(){
			skin.x = (highlight_mc.x = (shadow_mc.x = (body.GetPosition().x * scale)));
			skin.y = (highlight_mc.y = (shadow_mc.y = (body.GetPosition().y * scale)));
			skin.rotation = (body.GetAngle() * 57.2958);
		}
		public function zSetMass(massData){
			body.SetMass(massData);
		}
		public function SetSkin(shade:String=null, color=0xD2D2D2, alpha=1, pskin=null){
		}
		public function zSetMassFromShapes(){
			body.SetMassFromShapes();
		}

	}
}//package zahid.games.game59.item 
Section 216
//zmeterials (zahid.games.game59.item.zmeterials)
package zahid.games.game59.item {
	import Box2D.Collision.Shapes.*;

	public class zmeterials {

		private var cWoodSkinClass:Class;
		private var rock1SkinClass:Class;
		private var wood1SkinClass:Class;
		private var cBallSkinClass:Class;

		public function zmeterials(){
			rock1SkinClass = zmeterials_rock1SkinClass;
			wood1SkinClass = zmeterials_wood1SkinClass;
			cBallSkinClass = zmeterials_cBallSkinClass;
			cWoodSkinClass = zmeterials_cWoodSkinClass;
			super();
		}
		public function mlt_circle_wood():Object{
			var _object:Object = new Object();
			_object.mltDef = new b2PolygonDef();
			_object.mltDef.friction = 0;
			_object.mltDef.restitution = 0.1;
			_object.mltDef.density = 5;
			_object.skin = new cWoodSkinClass();
			_object.skinType = "swf";
			_object.color = 0xFF0000;
			_object.alpha = 1;
			return (_object);
		}
		public function mlt_rock1():Object{
			var _object:Object = new Object();
			_object.mltDef = new b2PolygonDef();
			_object.mltDef.friction = 1;
			_object.mltDef.restitution = 0.2;
			_object.mltDef.density = 1;
			_object.skin = new rock1SkinClass();
			_object.skinType = "bitmap";
			_object.color = 0xFF0000;
			_object.alpha = 1;
			return (_object);
		}
		public function mlt_blank():Object{
			var _object:Object = new Object();
			_object.mltDef = new b2PolygonDef();
			return (_object);
		}
		public function mlt_circle_ball1():Object{
			var _object:Object = new Object();
			_object.mltDef = new b2PolygonDef();
			_object.mltDef.friction = 0.5;
			_object.mltDef.restitution = 2;
			_object.mltDef.density = 0.5;
			_object.skin = new cBallSkinClass();
			_object.skinType = "swf";
			_object.hasHighlight = true;
			_object.color = 0xFF0000;
			_object.alpha = 1;
			return (_object);
		}
		public function mlt_wood1():Object{
			var _object:Object = new Object();
			_object.mltDef = new b2PolygonDef();
			_object.mltDef.friction = 0.5;
			_object.mltDef.restitution = 0.2;
			_object.mltDef.density = 0.5;
			_object.skin = new wood1SkinClass();
			_object.skinType = "bitmap";
			_object.color = 0xFF0000;
			_object.alpha = 1;
			return (_object);
		}

	}
}//package zahid.games.game59.item 
Section 217
//zmeterials_cBallSkinClass (zahid.games.game59.item.zmeterials_cBallSkinClass)
package zahid.games.game59.item {
	import flash.display.*;
	import mx.core.*;

	public class zmeterials_cBallSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item 
Section 218
//zmeterials_cWoodSkinClass (zahid.games.game59.item.zmeterials_cWoodSkinClass)
package zahid.games.game59.item {
	import flash.display.*;
	import mx.core.*;

	public class zmeterials_cWoodSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.item 
Section 219
//zmeterials_rock1SkinClass (zahid.games.game59.item.zmeterials_rock1SkinClass)
package zahid.games.game59.item {
	import mx.core.*;

	public class zmeterials_rock1SkinClass extends BitmapAsset {

	}
}//package zahid.games.game59.item 
Section 220
//zmeterials_wood1SkinClass (zahid.games.game59.item.zmeterials_wood1SkinClass)
package zahid.games.game59.item {
	import mx.core.*;

	public class zmeterials_wood1SkinClass extends BitmapAsset {

	}
}//package zahid.games.game59.item 
Section 221
//credits (zahid.games.game59.levels.credits)
package zahid.games.game59.levels {
	import flash.display.*;

	public class credits extends level {

		var bBack:DisplayObject;
		private var creditClass:Class;

		public function credits(){
			creditClass = credits_creditClass;
			bBack = new creditClass();
			super();
			m_sprite.addChild(renderCanvas);
			Main.Stage.addChildAt(m_sprite, 0);
			renderCanvas.addChild(bBack);
		}
	}
}//package zahid.games.game59.levels 
Section 222
//credits_creditClass (zahid.games.game59.levels.credits_creditClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class credits_creditClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 223
//level (zahid.games.game59.levels.level)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.utils.*;
	import com.roguedevelopment.pulse.particle.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import com.roguedevelopment.pulse.*;
	import flash.filters.*;
	import com.boostworthy.animation.management.*;
	import com.roguedevelopment.pulse.emitter.*;
	import zahid.games.game59.item.*;
	import com.parallax.*;
	import com.gmac.sound.*;
	import flash.text.*;
	import com.boostworthy.animation.rendering.*;
	import com.boostworthy.animation.easing.*;
	import com.roguedevelopment.pulse.rule.*;
	import zahid.games.game59.item.shape.*;
	import com.roguedevelopment.pulse.initializers.*;
	import zahid.games.game59.*;

	public class level {

		var infoShown:Boolean;// = false
		public var m_physScale:Number;// = 30
		var emitterSpark:GenericEmitter;
		var _maxTime:Number;// = 0
		public var m_drawScale;
		private var levelEndingScreen:Class;
		var _attemptCount:int;// = 1
		public var m_contactListener;
		public var endScreen:Sprite;
		var meterial:zmeterials;
		var gamesoundState:Boolean;
		public var paused:Boolean;// = false
		var parallaxWorld:Parallax;
		var _description:String;// = null
		public var infoWindow:Sprite;
		public var m_world:b2World;
		private var takeSkinClass:Class;
		public var m_iterations:int;// = 60
		public var m_bomb:b2Body;
		var levelArtArray:Array;
		private var infoWindowSkinClass:Class;
		var $soundLevelEnding:SoundSkin;
		public var _infoText:TextField;
		private var zoomMaskSkinClass:Class;
		var _name:String;// = null
		private var soundHit01Class:Class;
		public var drawnObject:Array;
		var dbgDraw:b2DebugDraw;
		public var renderCanvas:Sprite;
		var $soundTouch:SoundSkin;
		private var soundLevelEndingClass:Class;
		public var st_stage;
		var _maxSpeed:Number;// = 0
		var dyanItemArray:Array;
		private var pauseSkinClass:Class;
		var _Completed:Boolean;// = false
		public var _style:StyleSheet;
		var styleBoard:StyleSheet;
		public var _id:int;// = 0
		public var levelEndFlag:Boolean;// = false
		public var m_timeStep:Number;// = 0.0166666666666667
		protected var m_objAnimationManager:AnimationManager;
		var zoom:Boolean;// = false
		public var m_sprite;
		var autoReset:Boolean;// = false
		var bike;
		var loadScreen;
		public var m_mouseJoint:b2MouseJoint;
		var _currentRestorePoint:b2Vec2;

		public static var mouseYWorldPhys:Number;
		public static var mouseXWorldPhys:Number;
		public static var _KozMinProHeavy:String = "level__KozMinProHeavy";
		public static var mouseYWorld:Number;
		public static var mouseXWorld:Number;

		public function level(){
			infoWindowSkinClass = level_infoWindowSkinClass;
			zoomMaskSkinClass = level_zoomMaskSkinClass;
			levelEndingScreen = level_levelEndingScreen;
			pauseSkinClass = level_pauseSkinClass;
			soundHit01Class = level_soundHit01Class;
			soundLevelEndingClass = level_soundLevelEndingClass;
			takeSkinClass = level_takeSkinClass;
			infoWindow = new Sprite();
			endScreen = new Sprite();
			dbgDraw = new b2DebugDraw();
			levelArtArray = new Array();
			_style = new StyleSheet();
			styleBoard = new StyleSheet();
			_infoText = new TextField();
			$soundTouch = new SoundSkin(new soundHit01Class());
			$soundLevelEnding = new SoundSkin(new soundLevelEndingClass());
			drawnObject = new Array();
			renderCanvas = new Sprite();
			m_contactListener = new zContactListener(this);
			dyanItemArray = new Array();
			meterial = new zmeterials();
			super();
			m_objAnimationManager = new AnimationManager();
			parallaxWorld = new Parallax(Main.Stage);
			parallaxWorld.name = "parallaxWorld";
			Main.Stage.addChildAt(parallaxWorld, 0);
			infoWindow.name = "infoWindow";
			m_sprite = new Sprite();
			m_sprite.name = "m_sprite";
			st_stage = Main.Stage;
			m_drawScale = Main.m_drawScale;
			var worldAABB:b2AABB = new b2AABB();
			worldAABB.lowerBound.Set(-1000, -1000);
			worldAABB.upperBound.Set(1000, 1000);
			var gravity:b2Vec2 = new b2Vec2(0, 40);
			var doSleep:Boolean;
			m_world = new b2World(worldAABB, gravity, doSleep);
			dbgDraw.m_sprite = m_sprite;
			dbgDraw.m_drawScale = Main.m_drawScale;
			dbgDraw.m_fillAlpha = 0.3;
			dbgDraw.m_lineThickness = 1;
			m_world.SetContactListener(m_contactListener);
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			styleBoard.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:22},.take{color:#ff0000; fontWeight:bold; fontSize:16;},.number{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_infoText.autoSize = TextFieldAutoSize.CENTER;
			_infoText.multiline = true;
			_infoText.mouseEnabled = false;
			_infoText.embedFonts = true;
			sparkReady();
		}
		public function resetPlayer(){
		}
		public function CreateCircle(circleDef, userdata, meterial){
			var ball:* = new zcircle(m_world, renderCanvas, circleDef, meterial, m_drawScale, userdata);
			ball.SetSkin(meterial.skinType, meterial.color, meterial.alpha, meterial.skin);
			drawnObject.push(ball);
			return (ball);
		}
		public function ContactRemoveHandler(point:b2ContactPoint){
			bike.ContactRemoveHandler(point);
		}
		public function CreateBox(paths:Array, userdata, meterial){
			var box:* = new zbox(m_world, renderCanvas, paths, m_drawScale, userdata, meterial);
			box.SetSkin(meterial.skinType, meterial.color, meterial.alpha, meterial.skin);
			drawnObject.push(box);
			return (box);
		}
		public function showInfoWindow(infoTextField){
			infoWindow = new Sprite();
			var background:* = new infoWindowSkinClass();
			infoWindow.addChild(background);
			infoWindow.addChild(infoTextField);
			if (Main.infoWindow.numChildren > 0){
				Main.infoWindow.removeChildAt(0);
			};
			Main.infoWindow.addChild(infoWindow);
			background.width = (infoTextField.textWidth + 50);
			background.height = (infoTextField.textHeight + 30);
			infoTextField.x = (background.x + 10);
			infoTextField.y = (background.y + 10);
			infoWindow.x = ((Main.Stage.stageWidth / 2) - (background.width / 2));
			infoWindow.y = 20;
			infoShown = true;
			Main.infoWindow.visible = infoShown;
		}
		public function showHideInforWindow(){
			infoShown = !(infoShown);
			Main.infoWindow.visible = infoShown;
		}
		public function showTake(){
			if (Main.takeScreen.numChildren > 0){
				Main.takeScreen.removeChildAt(0);
			};
			var takeScreen:* = new takeSkinClass();
			Main.takeScreen.addChild(takeScreen);
			takeScreen.text_mc.txt.htmlText = (((("<p >" + _name) + "&#xD;<span class='take'>take - #</span>") + _attemptCount) + "</p>");
		}
		public function ContactResultHandler(point:b2ContactResult){
			var volume:*;
			bike.ContactResultHandler(point);
			if (((((!((point.shape1.GetBody().GetUserData().type == "sensor"))) || (!(!((point.shape2.GetBody().GetUserData().type == "sensor")))))) && ((point.normalImpulse > 10)))){
				emitterSpark.particleLimit = point.normalImpulse;
				emitterSpark.start();
				emitterSpark.x = (point.position.x * m_drawScale);
				emitterSpark.y = (point.position.y * m_drawScale);
				if (Main.gamesound){
					volume = point.normalImpulse;
					if (volume > 100){
						volume = 1;
					} else {
						volume = (volume / 100);
					};
					$soundTouch.volume = volume;
					$soundTouch.play();
				};
			};
		}
		public function pausePlay(ppause=false){
			var pauseSkin:*;
			if (((m_timeStep) || (ppause))){
				if (Main.pauseScreen.numChildren > 0){
					Main.pauseScreen.removeChildAt(0);
				};
				pauseSkin = new pauseSkinClass();
				Main.pauseScreen.addChild(pauseSkin);
				m_timeStep = 0;
				paused = true;
				gamesoundState = Main.gamesound;
				Main.gamesound = false;
			} else {
				if (Main.pauseScreen.numChildren > 0){
					Main.pauseScreen.removeChildAt(0);
				};
				m_timeStep = (1 / 60);
				Main.gamesound = gamesoundState;
				paused = false;
			};
		}
		public function responseSensor(item){
		}
		public function toggleZoom(){
			var zoomMaskSkin:*;
			if (zoom){
				m_timeStep = (1 / 60);
				parallaxWorld.width = (parallaxWorld.width * 2);
				parallaxWorld.height = (parallaxWorld.height * 2);
				parallaxWorld.y = 0;
				Main.Stage.removeChild(Main.Stage.getChildByName("zoomMaskSkin"));
			} else {
				m_timeStep = 0;
				parallaxWorld.width = (parallaxWorld.width / 2);
				parallaxWorld.height = (parallaxWorld.height / 2);
				parallaxWorld.y = 100;
				zoomMaskSkin = new zoomMaskSkinClass();
				zoomMaskSkin.name = "zoomMaskSkin";
				Main.Stage.addChild(zoomMaskSkin);
				Main.infoWindow.visible = false;
			};
			zoom = !(zoom);
		}
		public function comment(){
			var _comment:String = new String();
			_comment = (_attemptCount + " take");
			_comment = (_comment + ((_attemptCount)>1) ? "s. " : ". ");
			switch (_attemptCount){
				case 1:
					_comment = (_comment + "You are the man");
					break;
				case 2:
					_comment = (_comment + "Superb");
					break;
				case 3:
					_comment = (_comment + "Great job");
					break;
				case 4:
					_comment = (_comment + "Good work");
					break;
				case 5:
					_comment = (_comment + "Not bad at all");
					break;
				case 6:
					_comment = (_comment + "Ummm...");
					break;
				case 7:
					_comment = (_comment + "Seen better");
					break;
				case 8:
					_comment = (_comment + "Get better quick");
					break;
				case 9:
					_comment = (_comment + "Worthless");
					break;
				case 10:
					_comment = (_comment + "Are you kidding me?");
					break;
				default:
					_comment = (_comment + "If only I had someone else to work with");
					break;
			};
			return (_comment);
		}
		public function createStaticEdge(pdata:Array, world:b2World, name:String="untitled", sensorFlag:Boolean=false):void{
			var tmpArr:*;
			var chainDef:b2StaticEdgeChainDef = new b2StaticEdgeChainDef();
			chainDef.friction = 1;
			chainDef.restitution = 0.2;
			chainDef.isSensor = sensorFlag;
			var i:* = 0;
			while (i < pdata.length) {
				tmpArr = pdata[i].split(",");
				chainDef.vertices.push(new b2Vec2((tmpArr[0] / m_drawScale), (tmpArr[1] / m_drawScale)));
				i++;
			};
			chainDef.vertexCount = chainDef.vertices.length;
			world.CreateGroundShape(chainDef);
		}
		public function showEnding(){
			var ending:* = new levelEndingScreen();
			if (Main.endScreen.numChildren > 0){
				Main.endScreen.removeChildAt(0);
			};
			Main.endScreen.addChild(ending);
			var filter1:DropShadowFilter = new DropShadowFilter();
			ending.filters = [filter1];
			Main.endScreen.x = ((Main.Stage.stageWidth / 2) - (ending.width / 2));
			Main.endScreen.y = ((Main.Stage.stageHeight / 2) - (ending.height / 2));
			ending.elements.visible = false;
			ending.elements.txt.text = comment();
			bike.forceBreak();
		}
		public function ContactAddHandler(point:b2ContactPoint){
			if ((((point.shape1.GetBody().GetUserData().name == "head")) || ((point.shape2.GetBody().GetUserData().name == "head")))){
				m_objAnimationManager.brightness(parallaxWorld, 80, 500, Transitions.CUBIC_OUT, RenderMethod.TIMER);
			};
			bike.ContactAddHandler(point);
		}
		public function removeItem(item){
			item._delete();
			drawnObject.splice(drawnObject.indexOf(item), 1);
		}
		public function clearDynamicItems(){
			var item:*;
			for each (item in dyanItemArray) {
				removeItem(item);
			};
			dyanItemArray = new Array();
		}
		public function levelEnd(){
			if (!levelEndFlag){
				if (Main.infoWindow.numChildren > 0){
					Main.infoWindow.removeChildAt(0);
				};
				showEnding();
				if (Main.gamesound){
					$soundLevelEnding.play();
					//unresolved jump
				};
				levelEndFlag = true;
				bike.controlLock = true;
				(Main.m_tests.indexOf(this) + 1);
				if (Main.unlockpos < (_id + 1)){
					Main.unlockpos = (_id + 1);
					//unresolved jump
				};
			};
		}
		public function syncSkin(){
			var i:* = 0;
			while (i < drawnObject.length) {
				if (!drawnObject[i].body.IsSleeping()){
					drawnObject[i].sync();
				};
				i++;
			};
		}
		public function unloadLevel(){
			var item:*;
			var target:DisplayObject;
			$soundTouch.stop();
			$soundLevelEnding.stop();
			var i:* = 0;
			while (i < m_sprite.numChildren) {
				target = m_sprite.getChildAt(i);
				target.visible = false;
				m_sprite.removeChild(target);
				target = null;
				i++;
			};
			clearDynamicItems();
			for each (item in levelArtArray) {
				item = null;
			};
			Main.Stage.removeChild(parallaxWorld);
			parallaxWorld = null;
			levelArtArray = null;
			if (bike != null){
				bike.remove();
			};
			if (Main.infoWindow.numChildren > 0){
				Main.infoWindow.removeChildAt(0);
			};
			if (Main.takeScreen.numChildren > 0){
				Main.takeScreen.removeChildAt(0);
			};
			if (Main.endScreen.numChildren > 0){
				Main.endScreen.removeChildAt(0);
			};
			endScreen = new MovieClip();
			infoWindow = new MovieClip();
			infoShown = false;
		}
		public function sparkReady(){
			PulseEngine.instance.root = renderCanvas;
			var rules:Array = [];
			rules.push(new MovementRule());
			rules.push(new DeathRule(1000));
			rules.push(new FadeRule(1000));
			rules.push(new GravityRule(3));
			rules.push(new ScaleRule(100, 0.2, 1));
			var initializers:Array = [];
			initializers.push(new ParameterRandomizerInitializer("speed", 90, 100, true));
			initializers.push(new AngleRandomizerInitializer(0, 360));
			var particleSmokeFactory:* = new GenericFactory(DotSparkParticle, rules, initializers);
			emitterSpark = new GenericEmitter(5000);
			emitterSpark.particleLimit = 5;
			emitterSpark.setFactory(particleSmokeFactory);
			emitterSpark.stop();
		}
		public function dynamicItems(){
		}
		public function Update():void{
			var tmpTakeScreen:*;
			if (Main.takeScreen.numChildren > 0){
				tmpTakeScreen = Main.takeScreen.getChildAt(0);
				if (tmpTakeScreen.currentFrame == tmpTakeScreen.totalFrames){
					Main.takeScreen.removeChildAt(0);
					//unresolved jump
				};
				tmpTakeScreen = null;
			};
			if (Main.endScreen.numChildren > 0){
				tmpTakeScreen = Main.endScreen.getChildAt(0);
				if (tmpTakeScreen.currentFrame == tmpTakeScreen.totalFrames){
					tmpTakeScreen.stop();
					tmpTakeScreen.elements.visible = true;
				};
			};
			var physStart:uint = getTimer();
			m_world.Step(m_timeStep, m_iterations);
			Main.m_fpsCounter.updatePhys(physStart);
			syncSkin();
			if (bike != null){
				if (((((bike.IsFallen()) && (bike.IsDead()))) && (!(levelEndFlag)))){
					resetPlayer();
					//unresolved jump
				};
				//unresolved jump
			};
		}
		public function CreateCustomShape(paths:Array, userdata, meterial){
			var cshape:* = new zcustomshape(m_world, renderCanvas, paths, m_drawScale, userdata, meterial);
			cshape.SetSkin(meterial.skinType, meterial.color, meterial.alpha, meterial.skin);
			drawnObject.push(cshape);
			return (cshape);
		}
		public function ContactPersistHandler(point:b2ContactPoint){
			bike.ContactPersistHandler(point);
			if ((((((point.shape1.GetBody().GetUserData().name == "bbody")) && ((point.shape2.GetBody().GetUserData().type == "sensor")))) || ((((point.shape2.GetBody().GetUserData().name == "bbody")) && ((point.shape1.GetBody().GetUserData().type == "sensor")))))){
				if ((point.shape1.GetBody().GetUserData().type = "sensor")){
					responseSensor(point.shape1.GetBody().GetUserData());
				} else {
					responseSensor(point.shape2.GetBody().GetUserData());
				};
			};
		}

	}
}//package zahid.games.game59.levels 
Section 224
//level__KozMinProHeavy (zahid.games.game59.levels.level__KozMinProHeavy)
package zahid.games.game59.levels {
	import mx.core.*;

	public class level__KozMinProHeavy extends FontAsset {

	}
}//package zahid.games.game59.levels 
Section 225
//level_infoWindowSkinClass (zahid.games.game59.levels.level_infoWindowSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_infoWindowSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 226
//level_levelEndingScreen (zahid.games.game59.levels.level_levelEndingScreen)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_levelEndingScreen extends MovieClipAsset {

		public var txt:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 227
//level_pauseSkinClass (zahid.games.game59.levels.level_pauseSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_pauseSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 228
//level_soundHit01Class (zahid.games.game59.levels.level_soundHit01Class)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_soundHit01Class extends SoundAsset {

		public var txt:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 229
//level_soundLevelEndingClass (zahid.games.game59.levels.level_soundLevelEndingClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_soundLevelEndingClass extends SoundAsset {

		public var txt:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 230
//level_takeSkinClass (zahid.games.game59.levels.level_takeSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_takeSkinClass extends MovieClipAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 231
//level_zoomMaskSkinClass (zahid.games.game59.levels.level_zoomMaskSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level_zoomMaskSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 232
//level1 (zahid.games.game59.levels.level1)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level1 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		private var lightMask2StaticSkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public static var _keybrdcn:String = "level1__keybrdcn";

		public function level1(){
			var userdata:*;
			background1SkinClass = level1_background1SkinClass;
			background2SkinClass = level1_background2SkinClass;
			backgroundMainStageSkinClass = level1_backgroundMainStageSkinClass;
			backStaticSkinClass = level1_backStaticSkinClass;
			lightMask1StaticSkinClass = level1_lightMask1StaticSkinClass;
			lightMask2StaticSkinClass = level1_lightMask2StaticSkinClass;
			tasks = [false, false];
			super();
			_id = 1;
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_name = "Stunt Training School";
			_description = "Tutorial";
			_Completed = false;
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			levelArtArray.push(l2);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.cacheAsBitmap = true;
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			var lightMask2:* = new lightMask2StaticSkinClass();
			lightMask2.cacheAsBitmap = true;
			lightMask2.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask2);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l2, 0, 100, 1000);
			parallaxWorld.addPlane(l1, 0, 100, 500);
			parallaxWorld.addPlane(lightMask2, 0, 0, 0, true);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("6968.818359,983.832520", "6968.818359,27.771973", "0.265625,27.771973", "0.265625,983.832520", "6968.818359,983.832520");
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("1.234863,839.078613", "1332.968750,839.078613", "1578.919434,755.095215", "3504.535156,755.095215", "3926.403809,569.132813", "3926.403809,605.125488", "3896.409668,611.124512", "3896.409668,827.081055", "4025.384277,956.055176", "4440.345215,956.055176", "4569.319824,827.081055", "4569.319824,593.127930", "4536.325684,587.129395", "4536.325684,560.133789", "4962.240723,560.133789", "5796.073730,827.081055", "7907.645996,827.081055", "7907.645996,1444.957520", "1.234863,1444.957520", "1.234863,839.078613");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(918.035645, 1049.780762), new Point(795.023438, 0));
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(2715.401855, 1049.780762), new Point(2387.667969, 0));
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			var sensor6Path:Array = new Array(new Point(3115.401855, 1049.780762), new Point(3087.667969, 0));
			userdata = new b2zUserData("sensor6", "sensor");
			CreateBox(sensor6Path, userdata, meterial.mlt_blank());
			var sensor3Path:Array = new Array(new Point(4942.230957, 1049.78076), new Point(4659.008301, 0));
			userdata = new b2zUserData("sensor3", "sensor");
			CreateBox(sensor3Path, userdata, meterial.mlt_blank());
			var sensor4Path:Array = new Array(new Point(6895.800293, 1049.780762), new Point(6772.787598, 0));
			userdata = new b2zUserData("sensor4", "sensor");
			CreateBox(sensor4Path, userdata, meterial.mlt_blank());
			var sensor5Path:Array = new Array(new Point(4569.030762, 1049.780762), new Point(3900.92334, 863.07373));
			userdata = new b2zUserData("sensor5", "sensor");
			CreateBox(sensor5Path, userdata, meterial.mlt_blank());
			dynamicItems();
			_currentRestorePoint = new b2Vec2(3, 27);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			bike.excelVal = 50;
			_infoText.htmlText = "<p>Welcome back to the school. &#xD; Lets start. Go to point A. &#xD; Press <span class='key'>i</span> to ACCELERATE &#xD; Press <span class='key'>k</span> to BACK UP &#xD; Press <span class='key'>H</span> to hide this &#xD; Press <span class='key'>Q</span> to leave school &#xD;<span class='task'>Go to point A.</span></p>";
			showInfoWindow(_infoText);
		}
		override public function dynamicItems(){
			var userdata:*;
			var dyanItem1Path:Array = new Array(new Point(6534, 827), new Point(6289, 779));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem1Path, userdata, meterial.mlt_rock1()));
			var dyanItem2Path:Array = new Array(new Point(6527, 779), new Point(6486, 737));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem2Path, userdata, meterial.mlt_wood1()));
			var dyanItem4Path:Array = new Array(new Point(6318.684082, 722.519531), new Point(6028.978027, 715.703125));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem4Path, userdata, meterial.mlt_wood1()));
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter());
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					if (item.vergin){
						_infoText.htmlText = "<p><span class='positive'>Very good! </span>&#xD;Lets learn to break.&#xD;You can BRAKE by pressing <span class='key'>v</span>. &#xD;<span class='task'> Lets take a brake at point B </span></p>";
						showInfoWindow(_infoText);
						_currentRestorePoint = new b2Vec2(30, 22);
					};
					break;
				case "sensor2":
					if (((((!(bike.IsFallen())) && (bike.standingUp()))) && ((bike.getSpeed() < 3)))){
						tasks[0] = true;
						_infoText.htmlText = "<p>Let's to learn to jump &#xD; Press <span class='key'>SPACE</span> to JUMP &#xD;<span class='task'>Reach point C</span></p> ";
						showInfoWindow(_infoText);
					};
					break;
				case "sensor6":
					_currentRestorePoint = new b2Vec2(90, 22);
					_infoText.htmlText = "<p>Press <span class='key'>SPACE</span> to JUMP</p> ";
					showInfoWindow(_infoText);
					break;
				case "sensor3":
					if (item.vergin){
						_infoText.htmlText = "<p>Reach finishing point</p>";
						showInfoWindow(_infoText);
						_currentRestorePoint = new b2Vec2(155, 12);
					};
					break;
				case "sensor4":
					if (((((!(bike.IsFallen())) && (bike.standingUp()))) && ((bike.getSpeed() < 3)))){
						levelEnd();
					};
					break;
				case "sensor5":
					_infoText.htmlText = "<p>When you get stucked somewhere, &#xD;you can press <span class='key'>R</span> to &#xD;restart from last restore point</p>";
					showInfoWindow(_infoText);
					_currentRestorePoint = new b2Vec2(90, 22);
					break;
				default:
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
		}

	}
}//package zahid.games.game59.levels 
Section 233
//level1__keybrdcn (zahid.games.game59.levels.level1__keybrdcn)
package zahid.games.game59.levels {
	import mx.core.*;

	public class level1__keybrdcn extends FontAsset {

	}
}//package zahid.games.game59.levels 
Section 234
//level1_background1SkinClass (zahid.games.game59.levels.level1_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level1_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 235
//level1_background2SkinClass (zahid.games.game59.levels.level1_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level1_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 236
//level1_backgroundMainStageSkinClass (zahid.games.game59.levels.level1_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level1_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 237
//level1_backStaticSkinClass (zahid.games.game59.levels.level1_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level1_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 238
//level1_lightMask1StaticSkinClass (zahid.games.game59.levels.level1_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level1_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 239
//level1_lightMask2StaticSkinClass (zahid.games.game59.levels.level1_lightMask2StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level1_lightMask2StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 240
//level10 (zahid.games.game59.levels.level10)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level10 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;

		public function level10(){
			var userdata:*;
			background1SkinClass = level10_background1SkinClass;
			background2SkinClass = level10_background2SkinClass;
			backgroundMainStageSkinClass = level10_backgroundMainStageSkinClass;
			backStaticSkinClass = level10_backStaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 2;
			_name = "Stunt Biker Audition";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			l2.filters = [filter1];
			levelArtArray.push(l2);
			var l3:* = new background2SkinClass();
			l3.cacheAsBitmap = true;
			l3.width = (l3.width / 2);
			l3.height = (l3.height / 2);
			l3.filters = [filter1];
			levelArtArray.push(l3);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l3, 0, 150, 5000);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(l1, 0, 100, 1000);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16089.255859,8304.230469", "46.091797,8304.230469", "46.091797,0.000000", "16089.255859,0.000000", "16089.255859,8304.230469");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("8.386719,5696.230469", "1751.051270,5696.230469", "1751.051270,5668.230469", "3019.051270,5668.230469", "3019.051270,5644.230469", "3755.051270,5644.230469", "3755.051270,5613.230469", "4415.051270,5613.230469", "4415.051270,5652.230469", "5115.051270,5652.230469", "5115.051270,5668.230469", "5887.051270,5668.230469", "5887.051270,5696.230469", "6775.051270,5696.230469", "7323.051270,5576.230469", "7691.051270,5576.230469", "8147.051270,5456.230469", "8147.051270,5696.230469", "8619.050781,5696.230469", "8619.050781,5456.230469", "9171.050781,5456.230469", "9171.050781,5424.230469", "9211.050781,5424.230469", "9211.050781,5456.230469", "9703.050781,5456.230469", "9703.050781,5444.628906", "9728.732422,5444.628906", "9728.732422,5456.230469", "10172.488281,5456.230469", "10172.488281,5444.628906", "10195.417969,5444.628906", "10195.417969,5456.230469", "10635.125000,5456.230469", "10635.125000,5444.628906", "10660.751953,5444.628906", "10660.751953,5456.230469", "11150.367188,5456.230469", "11150.367188,5696.230469", "11906.925781,5696.230469", "12666.050781,5448.230469", "12666.050781,5696.230469", "13576.050781,5696.230469", "13576.050781,5496.858887", "13994.050781,5696.230469", "14834.050781,5696.230469", "14834.050781,5665.431152", "14843.123047,5665.431152", "14843.123047,5696.230469", "15436.242188,5696.230469", "15436.242188,5663.246582", "15448.255859,5663.246582", "15448.255859,5696.230469", "16257.650391,5696.230469", "16257.650391,8499.745117", "0.501465,8499.745117", "8.386719,5696.230469");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(8838.613281, 12109.082031), new Point(8710.613281, 1021.082031));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(16002.681641, 12052.395508), new Point(15874.681641, 964.395996));
			sensor2Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			_currentRestorePoint = new b2Vec2(10, 175);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			showTake();
		}
		override public function dynamicItems(){
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 150, 250);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					_currentRestorePoint = new b2Vec2(220, 175);
					break;
				case "sensor2":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 241
//level10_background1SkinClass (zahid.games.game59.levels.level10_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level10_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 242
//level10_background2SkinClass (zahid.games.game59.levels.level10_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level10_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 243
//level10_backgroundMainStageSkinClass (zahid.games.game59.levels.level10_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level10_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 244
//level10_backStaticSkinClass (zahid.games.game59.levels.level10_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level10_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 245
//level2 (zahid.games.game59.levels.level2)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level2 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		private var lightMaskStaticSkinClass:Class;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		var filter1:BlurFilter;

		public function level2(){
			var l1:*;
			var userdata:*;
			background1SkinClass = level2_background1SkinClass;
			background2SkinClass = level2_background2SkinClass;
			backgroundMainStageSkinClass = level2_backgroundMainStageSkinClass;
			backStaticSkinClass = level2_backStaticSkinClass;
			lightMaskStaticSkinClass = level2_lightMaskStaticSkinClass;
			filter1 = new BlurFilter();
			super();
			_id = 6;
			_name = "Night Rain - Scene:33";
			_description = "Tutorial";
			_Completed = false;
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			l1 = new background1SkinClass();
			l1.cacheAsBitmap = true;
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			l2.filters = [filter1];
			levelArtArray.push(l2);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			var lightMask:* = new lightMaskStaticSkinClass();
			lightMask.cacheAsBitmap = true;
			lightMask.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			backgroundMainStage.width = (backgroundMainStage.width * 2);
			backgroundMainStage.height = (backgroundMainStage.height * 2);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l2, 0, 300, 3000);
			parallaxWorld.addPlane(l1, 0, 300, 1000);
			parallaxWorld.addPlane(lightMask, 0, 0, 0, true);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16043.164063,15875.299805", "0.000488,15875.299805", "0.000488,0.000000", "16043.164063,0.000000", "16043.164063,15875.299805");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("0.000488,3405.277344", "1558.752930,3405.277344", "1558.752930,3440.099121", "2844.322754,3440.099121", "2844.322754,3373.594727", "3285.371582,3373.594727", "3285.371582,11055.157227", "3751.198730,11055.157227", "3751.198730,3573.143066", "4924.604004,3573.143066", "4924.604004,3570.404297", "5122.748535,3429.458984", "5122.748535,3431.486328", "5247.006348,3431.486328", "5567.942871,3279.391602", "5567.942871,3281.516602", "5696.916992,3281.516602", "5696.916992,3278.378418", "6043.165039,3137.899414", "6043.165039,3141.488281", "6697.023926,3141.488281", "6697.023926,3283.143066", "8194.798828,3283.143066", "8307.076172,3246.333008", "8417.253906,3283.143066", "8489.208984,3283.143066", "8489.208984,11055.157227", "9712.230469,11055.157227", "9712.230469,3836.932129", "10841.093750,3836.932129", "11128.720703,4094.797363", "11382.902344,4094.797363", "11382.902344,4322.675781", "12419.804688,5252.279785", "12842.212891,5252.279785", "12842.212891,5630.977539", "13141.486328,5899.281738", "13141.486328,11055.157227", "13962.564453,11055.157227", "13962.564453,5899.281738", "16043.164063,5899.281738", "16043.164063,11318.946289", "0.000488,11318.946289", "0.000488,11103.118164", "0.000488,3405.277344");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(4175.728516, 156.125977), new Point(4367.421875, 3573.143555));
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(9990.425781, 188.074707), new Point(10214.066406, 3836.932129));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			var sensor3Path:Array = new Array(new Point(15677.326172, 411.716797), new Point(15869.019531, 5899.28125));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor3", "sensor");
			CreateBox(sensor3Path, userdata, meterial.mlt_blank());
			dynamicItems();
			_currentRestorePoint = new b2Vec2(3, 110);
			bike = new zmotorBike2(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			bike.bikerStrength = 60;
			bike.excelVal = 110;
			showTake();
		}
		override public function dynamicItems(){
			var userdata:*;
			var dyanItem1Path:Array;
			var dyanItem1Def:Array = new Array(new Point(1923.01123, 3402.394531), 12);
			userdata = new b2zUserData("dyanItem1", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem1Def, userdata, meterial.mlt_circle_ball1()));
			dyanItem1Path = new Array(new Point(2627.274414, 3430.262695), new Point(2617.4375, 3086));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem1Path, userdata, meterial.mlt_wood1()));
			dyanItem1Path = new Array(new Point(2987.929688, 3076.165039), new Point(2594.487305, 3056.493164));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem1Path, userdata, meterial.mlt_wood1()));
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter());
		}
		override public function responseSensor(item){
			if (item.vergin){
				switch (item.name){
					case "sensor1":
						_currentRestorePoint = new b2Vec2(130, 110);
						break;
					case "sensor2":
						_currentRestorePoint = new b2Vec2(340, 110);
						break;
					case "sensor3":
						if (((!(bike.IsFallen())) && (bike.standingUp()))){
							levelEnd();
						};
						break;
					default:
						break;
				};
				item.vergin = false;
			};
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike2(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 246
//level2_background1SkinClass (zahid.games.game59.levels.level2_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level2_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 247
//level2_background2SkinClass (zahid.games.game59.levels.level2_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level2_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 248
//level2_backgroundMainStageSkinClass (zahid.games.game59.levels.level2_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level2_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 249
//level2_backStaticSkinClass (zahid.games.game59.levels.level2_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level2_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 250
//level2_lightMaskStaticSkinClass (zahid.games.game59.levels.level2_lightMaskStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level2_lightMaskStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 251
//level3 (zahid.games.game59.levels.level3)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level3 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background3SkinClass:Class;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public function level3(){
			background1SkinClass = level3_background1SkinClass;
			background2SkinClass = level3_background2SkinClass;
			background3SkinClass = level3_background3SkinClass;
			backgroundMainStageSkinClass = level3_backgroundMainStageSkinClass;
			backStaticSkinClass = level3_backStaticSkinClass;
			lightMask1StaticSkinClass = level3_lightMask1StaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 10;
			_name = "Sky Walker - Scene:Final-1a";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			levelArtArray.push(l2);
			var l3:* = new background2SkinClass();
			l3.cacheAsBitmap = true;
			l3.width = (l3.width / 2);
			l3.height = (l3.height / 2);
			levelArtArray.push(l3);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.cacheAsBitmap = true;
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l3, 0, 150, 5000);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(l1, 0, 100, 1000);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16139.087891,15875.299805", "95.923828,15875.299805", "95.923828,0.000000", "16139.087891,0.000000", "16139.087891,15875.299805");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("48.000488,816.230469", "2608.000488,1488.230469", "4672.000488,3536.230469", "5072.000488,4656.230469", "5584.000488,4928.230469", "6656.000488,6320.230469", "6608.000488,6544.230469", "6784.000488,6896.230469", "7248.000488,7248.230469", "8432.000000,8448.230469", "8800.000000,8736.230469", "9376.000000,9376.230469", "9520.000000,9712.230469", "10816.000000,10448.230469", "11408.000000,11008.230469", "11824.000000,11920.230469", "12880.000000,12672.230469", "13536.000000,12672.230469", "13808.000000,12624.230469", "14128.000000,12512.230469", "14416.000000,12352.230469", "14704.000000,12192.230469", "14720.000000,12400.230469", "14480.000000,12672.230469", "14432.000000,12816.230469", "14448.000000,13136.230469", "14640.000000,13520.230469", "14784.000000,13712.230469", "14816.000000,13920.230469", "14784.000000,14192.230469", "14752.000000,14496.230469", "14896.000000,14752.230469", "14896.000000,14880.230469", "14896.000000,15120.230469", "15024.000000,15488.230469", "15184.000000,15664.230469", "15392.000000,15824.230469", "15664.000000,15728.230469", "15824.000000,15440.230469", "15904.000000,15152.230469", "15936.000000,14816.230469", "15952.000000,14416.230469", "15616.000000,13424.230469", "15472.000000,12960.230469", "15472.000000,12656.230469", "15472.000000,12352.230469", "15376.000000,12288.230469", "15312.000000,12192.230469", "15684.000000,12032.230469", "15747.123047,12067.409180", "16227.050781,12072.591797", "16240.000000,15984.230469", "0.000488,15952.230469", "48.000488,816.230469");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(16102.246094, 2308.996582), new Point(15862.4375, 7752.641602));
			sensor1Path.reverse();
			var userdata:* = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			_currentRestorePoint = new b2Vec2(10, 20);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			bike.bikeStrength = 120;
			bike.bikerStrength = 120;
			showTake();
		}
		override public function dynamicItems(){
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 250, 100);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 252
//level3_background1SkinClass (zahid.games.game59.levels.level3_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level3_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 253
//level3_background2SkinClass (zahid.games.game59.levels.level3_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level3_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 254
//level3_background3SkinClass (zahid.games.game59.levels.level3_background3SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level3_background3SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 255
//level3_backgroundMainStageSkinClass (zahid.games.game59.levels.level3_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level3_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 256
//level3_backStaticSkinClass (zahid.games.game59.levels.level3_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level3_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 257
//level3_lightMask1StaticSkinClass (zahid.games.game59.levels.level3_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level3_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 258
//level4 (zahid.games.game59.levels.level4)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level4 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background3SkinClass:Class;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public function level4(){
			var userdata:*;
			background1SkinClass = level4_background1SkinClass;
			background2SkinClass = level4_background2SkinClass;
			background3SkinClass = level4_background3SkinClass;
			backgroundMainStageSkinClass = level4_backgroundMainStageSkinClass;
			backStaticSkinClass = level4_backStaticSkinClass;
			lightMask1StaticSkinClass = level4_lightMask1StaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 3;
			_name = "My Town - Scene:110";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			levelArtArray.push(l2);
			var l3:* = new background2SkinClass();
			l3.width = (l3.width / 2);
			l3.height = (l3.height / 2);
			levelArtArray.push(l3);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			levelArtArray.push(backgroundMainStage);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l3, 0, 150, 5000);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16224.072266,15875.299805", "180.907715,15875.299805", "180.907715,0.000000", "16224.072266,0.000000", "16224.072266,15875.299805");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("3.341309,7605.889648", "989.738281,7605.889648", "989.738281,7576.749023", "1031.336914,7564.291016", "1074.231445,7538.844727", "1188.817871,7538.570801", "1222.988281,7564.291016", "1301.728516,7574.116211", "1301.728516,7599.458984", "1687.851074,7599.458984", "1687.851074,7576.749023", "1729.601074,7564.291016", "1768.282227,7534.630859", "1890.596680,7537.254395", "1948.648926,7564.291016", "2014.850098,7572.799316", "2014.850098,7599.458984", "3031.048340,7599.458984", "3030.389648,7598.801270", "3480.401855,7439.337891", "3480.401855,7458.090820", "3560.770020,7458.090820", "3604.972168,7502.292969", "3604.972168,7599.458984", "4785.039551,7599.458984", "4785.039551,7584.000977", "4801.113281,7584.000977", "4801.113281,7600.074707", "5224.384277,7597.395508", "5224.384277,7575.963867", "5243.136719,7575.963867", "5243.136719,7597.395508", "5604.792480,7597.395508", "5907.512207,7482.201660", "5963.769531,7482.201660", "5963.769531,7525.064453", "6038.779297,7525.064453", "6038.779297,7557.211426", "6113.789551,7557.211426", "6113.789551,7597.395508", "6271.846680,7597.395508", "6271.846680,7432.201660", "7410.291504,7432.201660", "7410.291504,7597.395508", "7664.788574,7597.395508", "7664.788574,7432.201660", "8779.306641,7432.201660", "8779.306641,7597.395508", "9507.847656,7597.395508", "9507.847656,7691.505859", "9786.455078,7691.505859", "9786.455078,7597.395508", "10558.199219,7597.395508", "11276.369141,7765.530273", "13267.480469,7765.530273", "13267.480469,6414.944336", "16211.921875,6414.944336", "16211.921875,7926.314453", "0.504395,7915.596680", "3.341309,7605.889648");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(6503.955566, 16928.5), new Point(6359.955566, 48.499023));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(12327.955078, 16416.5), new Point(12183.955078, 0.5));
			sensor2Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			_currentRestorePoint = new b2Vec2(10, 250);
			bike = new zmotorBike2(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			bike.bikerStrength = 60;
			bike.excelVal = 120;
			showTake();
		}
		override public function dynamicItems(){
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 100, 250);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					_currentRestorePoint = new b2Vec2(210, 245);
					break;
				case "sensor2":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike2(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 259
//level4_background1SkinClass (zahid.games.game59.levels.level4_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level4_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 260
//level4_background2SkinClass (zahid.games.game59.levels.level4_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level4_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 261
//level4_background3SkinClass (zahid.games.game59.levels.level4_background3SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level4_background3SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 262
//level4_backgroundMainStageSkinClass (zahid.games.game59.levels.level4_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level4_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 263
//level4_backStaticSkinClass (zahid.games.game59.levels.level4_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level4_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 264
//level4_lightMask1StaticSkinClass (zahid.games.game59.levels.level4_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level4_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 265
//level5 (zahid.games.game59.levels.level5)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level5 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background1SkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public function level5(){
			var userdata:*;
			background1SkinClass = level5_background1SkinClass;
			backgroundMainStageSkinClass = level5_backgroundMainStageSkinClass;
			backStaticSkinClass = level5_backStaticSkinClass;
			lightMask1StaticSkinClass = level5_lightMask1StaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 7;
			_name = "Junkyard Junkie- Scene:dock yard";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l1b:* = new background1SkinClass();
			l1b.cacheAsBitmap = true;
			levelArtArray.push(l1b);
			l1b.width = (l1b.width * 2);
			l1b.height = (l1b.height * 2);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.cacheAsBitmap = true;
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l1, 0, 100, 1000);
			parallaxWorld.addPlane(l1b, 0, 40, 500);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16224.072266,15875.299805", "180.907715,15875.299805", "180.907715,0.000000", "16224.072266,0.000000", "16224.072266,15875.299805");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("0.500000,7013.620117", "1591.615234,7013.620117", "2095.000000,6818.728027", "2095.000000,7013.620117", "2511.000000,7013.620117", "2511.000000,6695.849121", "2521.983398,6695.849121", "2521.983398,7008.230469", "3935.000000,7008.230469", "3935.000000,6993.230469", "4223.930664,6993.230469", "4223.930664,6976.225098", "4538.961914,6976.225098", "4538.961914,6957.949707", "4894.189941,6897.949707", "5247.000000,6726.230469", "5493.057129,6726.230469", "5493.057129,6771.938965", "5700.078125,6771.938965", "5700.078125,6840.945801", "5999.000000,6843.945313", "5999.000000,6904.230469", "6735.000000,6904.230469", "6735.000000,7008.230469", "8911.000000,7008.230469", "9263.000000,6832.230469", "9759.000000,6832.230469", "9759.000000,7008.230469", "10447.000000,7008.230469", "10447.000000,6832.230469", "10943.000000,6832.230469", "11535.000000,7008.230469", "12207.000000,7008.230469", "12207.000000,6984.960938", "12246.729492,6984.960938", "12246.729492,7008.230469", "13233.000000,7008.230469", "14063.958008,6786.940430", "14063.958008,7008.230469", "14481.000000,7008.230469", "14481.000000,6819.943848", "15189.219727,6819.943848", "15280.021484,6720.934082", "15595.960938,6720.934082", "15595.960938,6693.931152", "15801.744141,6576.357422", "16047.000000,6573.919434", "16047.000000,5120.230469", "16207.000000,5120.230469", "16207.000000,7616.230469", "0.500000,7616.230469", "0.500000,7013.620117");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(6255.5, 11760.230469), new Point(6127.5, 672.230469));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(16015.5, 11904.230469), new Point(15887.5, 816.230469));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			dynamicItems();
			_currentRestorePoint = new b2Vec2(10, 230);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			bike.bikerStrength = 80;
			bike.excelVal = 120;
			showTake();
		}
		override public function dynamicItems(){
			var userdata:*;
			var dyanItem1Path:Array = new Array(new Point(10514.273438, 6832.896484), new Point(10010.273438, 6816.896484));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem1Path, userdata, meterial.mlt_wood1()));
			var dyanItem2Path:Array = new Array(new Point(6463.730469, 6902.676758), 10);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem2Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem3Path:Array = new Array(new Point(6504.323242, 6902.676758), 15);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem3Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem4Path:Array = new Array(new Point(6544.916016, 6902.676758), 13);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem4Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem5Path:Array = new Array(new Point(6584.058594, 6902.676758), 7);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem5Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem6Path:Array = new Array(new Point(6561.763672, 6860.53418), 11);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem6Path, userdata, meterial.mlt_circle_wood()));
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 50, 250);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					_currentRestorePoint = new b2Vec2(207, 230);
					break;
				case "sensor2":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}

	}
}//package zahid.games.game59.levels 
Section 266
//level5_background1SkinClass (zahid.games.game59.levels.level5_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level5_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 267
//level5_backgroundMainStageSkinClass (zahid.games.game59.levels.level5_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level5_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 268
//level5_backStaticSkinClass (zahid.games.game59.levels.level5_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level5_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 269
//level5_lightMask1StaticSkinClass (zahid.games.game59.levels.level5_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level5_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 270
//level6 (zahid.games.game59.levels.level6)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level6 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background3SkinClass:Class;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public function level6(){
			var userdata:*;
			background1SkinClass = level6_background1SkinClass;
			background2SkinClass = level6_background2SkinClass;
			background3SkinClass = level6_background3SkinClass;
			backgroundMainStageSkinClass = level6_backgroundMainStageSkinClass;
			backStaticSkinClass = level6_backStaticSkinClass;
			lightMask1StaticSkinClass = level6_lightMask1StaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 8;
			_name = "Hiper Joe Revenge - Scene:41";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			levelArtArray.push(l2);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.cacheAsBitmap = true;
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(l1, 0, 100, 1000);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16224.072266,15875.299805", "180.907715,15875.299805", "180.907715,0.000000", "16224.072266,0.000000", "16224.072266,15875.299805");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("14.321777,7013.620117", "887.957031,7013.620117", "887.957031,6986.021484", "1458.768066,6986.021484", "1458.768066,6964.020020", "2251.576172,6964.020020", "2251.576172,6943.317871", "3051.229980,6943.317871", "3125.086426,6910.033203", "3125.086426,7013.620117", "3327.894531,7013.620117", "3327.894531,6926.317871", "4224.805664,6926.317871", "4250.156738,6900.966797", "4326.209961,6900.966797", "4358.386230,6933.143066", "4358.386230,7013.620117", "4439.314453,7013.620117", "4439.314453,6876.614258", "5157.564941,6876.614258", "5435.632324,6779.110840", "6363.323242,6779.110840", "6750.952148,6708.907715", "6750.953125,6779.110840", "7641.857422,6779.110840", "7641.857422,7013.620117", "8222.815430,7013.620117", "8554.399414,6915.818359", "8554.399414,7013.620117", "8671.404297,7013.620117", "8671.404297,6904.118164", "8694.805664,6904.118164", "8694.805664,6932.121094", "8944.415039,6932.121094", "8944.415039,6904.118164", "9342.231445,6904.118164", "9424.134766,6943.119629", "10799.517578,6943.119629", "10975.518555,7080.230469", "11135.522461,7080.230469", "11135.522461,6912.230469", "11263.521484,6912.230469", "11319.515625,7080.230469", "11671.518555,7080.230469", "12039.518555,6943.119629", "12516.516602,6943.119629", "12518.516602,6903.119629", "12648.518555,6880.230469", "12756.517578,6873.119629", "12820.517578,6873.119629", "12880.522461,6843.119629", "12932.522461,6843.119629", "12970.516602,6806.231934", "13028.513672,6792.230469", "13072.517578,6808.230469", "13112.516602,6843.119629", "13152.516602,6873.119629", "13254.517578,6903.119629", "13344.521484,6943.119629", "13491.393555,6929.561035", "13524.519531,6917.836426", "13600.523438,6869.680664", "13691.871094,6851.771973", "13870.048828,6813.322754", "13935.285156,6860.526855", "13995.211914,6862.682617", "14066.422852,6888.171875", "14097.237305,6878.486816", "14146.610352,6868.128418", "14201.985352,6881.175781", "14268.102539,6913.710449", "14319.969727,6889.239746", "14414.348633,6877.758789", "14483.545898,6901.381836", "14527.102539,6881.813965", "14622.074219,6899.621094", "14680.002930,6887.313965", "14798.300781,6891.568848", "14863.379883,6908.426270", "14914.385742,6882.866211", "14995.570313,6861.763184", "15073.954102,6845.181641", "15135.756836,6793.930664", "15251.826172,6766.797852", "15322.672852,6772.827148", "15383.062500,6755.155273", "15480.041992,6763.104492", "15562.712891,6815.568848", "15693.078125,6844.185547", "15823.446289,6942.549316", "16168.442383,6943.031738", "16212.448242,5950.680176", "16231.518555,5950.706543", "16231.518555,6943.119629", "16231.518555,7167.212402", "0.546875,7167.212402", "14.321777,7013.620117");
			createStaticEdge(groundPath, m_world, "ground");
			var groundPath2:Array = new Array("7099.394531,6636.855957", "7427.394531,6636.855957", "8187.394531,6266.855957", "9635.394531,6266.855957", "9635.394531,6256.855957", "8187.394531,6256.855957", "7427.394531,6616.855957", "7099.394531,6616.855957", "7099.394531,6636.855957");
			groundPath2.reverse();
			createStaticEdge(groundPath2, m_world, "ground");
			var groundPath3:Array = new Array("9902.258789,6275.715820", "10230.258789,6275.715820", "10990.258789,5905.715820", "12438.258789,5905.715820", "12438.258789,5895.715820", "10990.258789,5895.715820", "10230.258789,6255.715820", "9902.258789,6255.715820", "9902.258789,6275.715820");
			groundPath3.reverse();
			createStaticEdge(groundPath3, m_world, "ground");
			var groundPath4:Array = new Array("12890.360352,5917.224121", "13218.360352,5917.224121", "13978.360352,5547.224121", "15296.360352,6377.224121", "15296.360352,6367.224121", "13978.360352,5537.224121", "13218.360352,5897.224121", "12890.360352,5897.224121", "12890.360352,5917.224121");
			groundPath4.reverse();
			createStaticEdge(groundPath4, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(6255.5, 11760.230469), new Point(6127.5, 672.230469));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(16015.5, 11904.230469), new Point(15887.5, 816.230469));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			dynamicItems();
			_currentRestorePoint = new b2Vec2(10, 230);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			showTake();
		}
		override public function dynamicItems(){
			var userdata:*;
			var dyanItem1Path:Array = new Array(new Point(10514.273438, 6832.896484), new Point(10010.273438, 6816.896484));
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateBox(dyanItem1Path, userdata, meterial.mlt_wood1()));
			var dyanItem2Path:Array = new Array(new Point(6463.730469, 6902.676758), 10);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem2Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem3Path:Array = new Array(new Point(6504.323242, 6902.676758), 15);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem3Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem4Path:Array = new Array(new Point(6544.916016, 6902.676758), 13);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem4Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem5Path:Array = new Array(new Point(6584.058594, 6902.676758), 7);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem5Path, userdata, meterial.mlt_circle_wood()));
			var dyanItem6Path:Array = new Array(new Point(6561.763672, 6860.53418), 11);
			userdata = new b2zUserData("ground", "dyanItem");
			dyanItemArray.push(CreateCircle(dyanItem6Path, userdata, meterial.mlt_circle_wood()));
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 50, 250);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					_currentRestorePoint = new b2Vec2(207, 200);
					break;
				case "sensor2":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 271
//level6_background1SkinClass (zahid.games.game59.levels.level6_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level6_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 272
//level6_background2SkinClass (zahid.games.game59.levels.level6_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level6_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 273
//level6_background3SkinClass (zahid.games.game59.levels.level6_background3SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level6_background3SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 274
//level6_backgroundMainStageSkinClass (zahid.games.game59.levels.level6_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level6_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 275
//level6_backStaticSkinClass (zahid.games.game59.levels.level6_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level6_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 276
//level6_lightMask1StaticSkinClass (zahid.games.game59.levels.level6_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level6_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 277
//level7 (zahid.games.game59.levels.level7)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level7 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background3SkinClass:Class;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public function level7(){
			var groundPath3:Array;
			var userdata:*;
			background1SkinClass = level7_background1SkinClass;
			background2SkinClass = level7_background2SkinClass;
			background3SkinClass = level7_background3SkinClass;
			backgroundMainStageSkinClass = level7_backgroundMainStageSkinClass;
			backStaticSkinClass = level7_backStaticSkinClass;
			lightMask1StaticSkinClass = level7_lightMask1StaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 9;
			_name = "That Neighborhood - Scene:18";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			levelArtArray.push(l2);
			var l3:* = new background2SkinClass();
			l3.cacheAsBitmap = true;
			l3.width = (l3.width / 2);
			l3.height = (l3.height / 2);
			levelArtArray.push(l3);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.cacheAsBitmap = true;
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l3, 0, 150, 5000);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(l1, 0, 100, 1000);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16089.255859,8304.230469", "46.091797,8304.230469", "46.091797,0.000000", "16089.255859,0.000000", "16089.255859,8304.230469");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("0.500000,8327.759766", "2450.196777,8327.759766", "2450.196777,6881.795410", "2433.162109,6881.795410", "2433.163086,6913.504883", "1765.055176,6913.504883", "1765.055176,6897.355957", "1748.453125,6895.974609", "1748.453125,6913.504883", "1334.480469,6913.504883", "1278.027344,6913.504883", "1278.027344,6925.876953", "1264.205078,6925.832031", "1264.205078,6936.233398", "1249.752930,6936.233398", "1249.752930,6945.770508", "1233.739258,6945.770508", "1233.739258,6956.287109", "1216.521484,6956.287109", "1216.521484,6965.307617", "1199.516113,6965.307617", "1199.516113,6973.904785", "1182.795898,6973.904785", "1182.795898,6983.554199", "1165.598633,6983.554199", "1165.598633,6993.501953", "1147.778809,6993.501953", "1147.778809,7001.942871", "0.500000,7001.942871", "0.500000,8327.759766");
			groundPath.reverse();
			createStaticEdge(groundPath, m_world, "ground");
			var groundPath2:Array = new Array("2684.458008,8327.759766", "2684.458008,6963.956055", "2702.459473,6966.956543", "2702.459473,6996.959473", "2816.164063,6996.959473", "2816.164063,6975.873535", "2822.864258,6968.046875", "2884.620117,6968.046875", "2892.551758,6974.750000", "2892.551758,6996.959473", "3245.513672,6996.959473", "3245.513672,6974.955078", "3290.518555,6944.952148", "3314.520508,6944.952148", "3323.521484,6959.953613", "3337.023438,6973.455078", "3356.524902,6973.455078", "3356.524902,6996.959473", "3845.574219,6996.959473", "3845.574219,6969.956543", "3863.575684,6969.956543", "3863.575684,6996.959473", "5096.699219,6996.959473", "5096.699219,6984.236816", "5120.661621,6984.236816", "5120.661621,6971.567383", "5145.104492,6971.567383", "5145.104492,6959.155273", "5168.578125,6959.155273", "5168.578125,6946.969727", "5192.052246,6946.969727", "5192.052246,6934.526855", "5216.010254,6934.526855", "5216.010254,6923.083984", "5239.226563,6923.083984", "5239.226563,6911.383301", "5261.731445,6911.383301", "5261.731445,6899.455566", "5284.689453,6899.455566", "5284.689453,6887.786133", "5306.709961,6887.786133", "5306.709961,6876.600586", "5329.925781,6876.600586", "5329.925781,6864.126953", "5788.072754,6864.126953", "5788.072754,6842.130859", "5796.133789,6842.130859", "5795.994629,8327.758789", "2684.458008,8327.759766");
			createStaticEdge(groundPath2, m_world, "ground");
			groundPath3 = new Array("6036.184570,7013.620117", "6612.184570,7013.620117", "6612.184570,7031.665039", "6659.406738,7031.665039", "6659.406738,7047.620605", "6701.955078,7047.620605", "6701.955078,7062.512695", "6749.822266,7062.512695", "6749.822266,7078.468262", "6801.944824,7078.468262", "6801.944824,7093.360352", "6850.875488,7093.360352", "6850.875488,7107.188477", "6901.934082,7107.188477", "6901.934082,7121.017090", "6946.609863,7121.017090", "6946.609863,7133.781738", "6991.955566,7133.781738", "6991.955566,7146.455566", "7406.719727,7146.455566", "7406.719727,7480.230469", "7672.184570,7480.230469", "7672.184570,7146.455566", "8816.184570,7146.455566", "8816.184570,7480.230469", "9286.184570,7480.230469", "9286.184570,7146.455566", "10296.184570,7146.455566", "10296.184570,7134.944336", "10338.608398,7134.944336", "10338.608398,7118.673828", "10384.166992,7118.673828", "10384.166992,7101.318359", "10427.555664,7101.318359", "10427.555664,7085.047363", "10473.113281,7085.047363", "10473.113281,7070.946289", "10521.925781,7070.946289", "10521.925781,7055.760254", "10565.314453,7055.760254", "10565.314453,7040.574219", "10610.872070,7040.574219", "10610.872070,7027.557617", "10652.091797,7027.557617", "10652.091797,7013.620117", "11515.523438,7013.620117", "11601.215820,6964.644043", "11695.585938,7013.620117", "11881.068359,7013.620117", "11881.068359,8336.230469", "6036.184570,8336.230469", "6036.184570,7013.620117");
			createStaticEdge(groundPath3, m_world, "ground");
			groundPath3 = new Array("12453.588867,7020.754395", "13326.620117,7020.754395", "13326.620117,7010.875977", "13356.958008,7010.875977", "13356.958008,7001.044434", "13387.821289,7001.044434", "13387.821289,6989.247559", "13418.874023,6989.247559", "13418.874023,6977.844727", "13451.311523,6977.844727", "13451.311523,6965.659180", "13485.499023,6965.659180", "13485.499023,6953.273438", "13522.069336,6953.273438", "13522.069336,6940.298828", "13557.460938,6940.298828", "13557.460938,6926.936523", "13589.415039,6926.936523", "13589.415039,6914.533203", "13626.696289,6914.533203", "13626.696289,6902.105957", "13664.174805,6902.105957", "13664.174805,6890.270996", "13700.270508,6890.270996", "13700.270508,6875.477051", "14270.208008,6875.477051", "14270.208008,6870.823242", "14295.853516,6870.823242", "14295.853516,6875.477051", "14914.571289,6875.477051", "14914.571289,6548.770020", "16123.591797,6548.770020", "16123.591797,8350.234375", "12453.588867,8350.234375", "12453.588867,7020.754395");
			createStaticEdge(groundPath3, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(3547.291504, 11760.230469), new Point(3419.291504, 672.230469));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(8655.924805, 11928.297852), new Point(8527.924805, 840.297852));
			sensor2Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			var sensor3Path:Array = new Array(new Point(14900.18457, 8516.15625), new Point(14772.18457, 13634.230469));
			userdata = new b2zUserData("sensor3", "sensor");
			CreateBox(sensor3Path, userdata, meterial.mlt_blank());
			_currentRestorePoint = new b2Vec2(10, 230);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			showTake();
		}
		override public function dynamicItems(){
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 50, 250);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					_currentRestorePoint = new b2Vec2(100, 210);
					break;
				case "sensor2":
					_currentRestorePoint = new b2Vec2(260, 230);
					break;
				case "sensor3":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 278
//level7_background1SkinClass (zahid.games.game59.levels.level7_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level7_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 279
//level7_background2SkinClass (zahid.games.game59.levels.level7_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level7_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 280
//level7_background3SkinClass (zahid.games.game59.levels.level7_background3SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level7_background3SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 281
//level7_backgroundMainStageSkinClass (zahid.games.game59.levels.level7_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level7_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 282
//level7_backStaticSkinClass (zahid.games.game59.levels.level7_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level7_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 283
//level7_lightMask1StaticSkinClass (zahid.games.game59.levels.level7_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level7_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 284
//level8 (zahid.games.game59.levels.level8)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level8 extends level {

		private var backgroundMainStageOverlaySkinClass:Class;
		private var backStaticSkinClass:Class;
		private var backgroundMainStageSkinClass:Class;
		var tasks:Array;
		private var background2SkinClass:Class;
		private var background1SkinClass:Class;
		private var lightMask1StaticSkinClass:Class;

		public function level8(){
			var userdata:*;
			background1SkinClass = level8_background1SkinClass;
			background2SkinClass = level8_background2SkinClass;
			backgroundMainStageOverlaySkinClass = level8_backgroundMainStageOverlaySkinClass;
			backgroundMainStageSkinClass = level8_backgroundMainStageSkinClass;
			backStaticSkinClass = level8_backStaticSkinClass;
			lightMask1StaticSkinClass = level8_lightMask1StaticSkinClass;
			tasks = [false, false];
			super();
			_style.parseCSS("p{fontFamily:defaultFont;textalign:center;fontSize:14},.key{color:#ff6c00; fontFamily:keybroardFont; fontWeight:bold; fontSize:24;},.task{color:#ff0000; fontWeight:bold; fontSize:16;},.positive{color:#36a400; fontWeight:bold; fontSize:16;}");
			_infoText.styleSheet = _style;
			_id = 5;
			_name = "Mega Meltdown - Scene:12";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l1:* = new background1SkinClass();
			l1.cacheAsBitmap = true;
			l1.filters = [filter1];
			levelArtArray.push(l1);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			levelArtArray.push(l2);
			var l3:* = new backgroundMainStageOverlaySkinClass();
			l3.width = (l3.width * 10);
			l3.height = (l3.height * 10);
			levelArtArray.push(l3);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			var lightMask1:* = new lightMask1StaticSkinClass();
			lightMask1.cacheAsBitmap = true;
			lightMask1.blendMode = BlendMode.OVERLAY;
			levelArtArray.push(lightMask1);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			m_sprite.addChild(l3);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(lightMask1, 0, 0, 0, true);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16089.255859,8304.230469", "46.091797,8304.230469", "46.091797,0.000000", "16089.255859,0.000000", "16089.255859,8304.230469");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("23.503906,5044.677246", "839.503906,5044.677246", "2097.503906,4623.287598", "2097.503906,4767.287598", "1881.503906,4983.287598", "1649.503906,5407.287598", "2001.503906,5999.287598", "2001.503906,7007.287598", "3297.503906,7007.287598", "3297.503906,4847.287598", "3187.665527,4621.125977", "2853.610840,4679.287598", "2751.557617,4577.233887", "4254.934082,4168.696289", "4254.934082,4312.696289", "3745.503906,4477.211914", "3601.503906,4831.287598", "3601.503906,7007.287598", "5856.503906,7007.287598", "5856.503906,4266.833984", "5724.503906,4134.833984", "4840.503906,4178.833984", "4840.503906,4026.833984", "7344.503906,3810.833984", "7288.503906,3978.833984", "6288.503906,4090.833984", "6108.503906,4270.833984", "6108.503906,7007.287598", "8992.503906,7007.287598", "8992.503906,4282.833984", "8808.503906,4098.833984", "8064.503906,3994.833984", "8064.503906,3818.833984", "10472.503906,4138.833984", "10316.503906,4294.833984", "9392.503906,4194.833984", "9268.503906,4318.833984", "9268.503906,7007.287598", "12328.503906,7007.287598", "12328.503906,4808.833984", "12168.503906,4648.833984", "11288.503906,4464.833984", "11288.503906,4296.833984", "13696.503906,4680.833984", "13548.503906,4828.833984", "12688.503906,4736.833984", "12576.503906,4848.833984", "12576.503906,7007.287598", "15160.503906,7007.287598", "15160.503906,5328.833984", "15012.503906,5180.833984", "14704.503906,5080.833984", "14648.503906,4920.833984", "15600.503906,4992.833984", "16224.503906,4992.833984", "16224.503906,5176.833984", "15552.503906,5232.833984", "15400.503906,5384.833984", "15400.503906,7007.287598", "16240.503906,7007.287598", "16232.503906,8048.833984", "0.503906,8072.833984", "23.503906,5044.677246");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(16153.575195, 6816.912109), new Point(35.265625, 6528.833984));
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(15991.503906, 5970.426758), new Point(15863.503906, 11088.500977));
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			_currentRestorePoint = new b2Vec2(10, 145);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			showTake();
		}
		override public function dynamicItems(){
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 150, 150);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					break;
				case "sensor2":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}

	}
}//package zahid.games.game59.levels 
Section 285
//level8_background1SkinClass (zahid.games.game59.levels.level8_background1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level8_background1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 286
//level8_background2SkinClass (zahid.games.game59.levels.level8_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level8_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 287
//level8_backgroundMainStageOverlaySkinClass (zahid.games.game59.levels.level8_backgroundMainStageOverlaySkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level8_backgroundMainStageOverlaySkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 288
//level8_backgroundMainStageSkinClass (zahid.games.game59.levels.level8_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level8_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 289
//level8_backStaticSkinClass (zahid.games.game59.levels.level8_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level8_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 290
//level8_lightMask1StaticSkinClass (zahid.games.game59.levels.level8_lightMask1StaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level8_lightMask1StaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 291
//level9 (zahid.games.game59.levels.level9)
package zahid.games.game59.levels {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import flash.display.*;
	import flash.geom.*;
	import Box2D.Common.Math.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;
	import flash.filters.*;
	import zahid.games.game59.item.*;
	import zahid.games.game59.item.shape.*;
	import zahid.games.common.*;

	public class level9 extends level {

		private var backgroundMainStageSkinClass:Class;
		private var backStaticSkinClass:Class;
		var tasks:Array;
		private var background2SkinClass:Class;

		public function level9(){
			var userdata:*;
			background2SkinClass = level9_background2SkinClass;
			backgroundMainStageSkinClass = level9_backgroundMainStageSkinClass;
			backStaticSkinClass = level9_backStaticSkinClass;
			tasks = [false, false];
			super();
			_id = 4;
			_name = "Runway - Scene:37";
			_description = "Tutorial";
			_Completed = false;
			var filter1:BlurFilter = new BlurFilter();
			var backStatic:* = new backStaticSkinClass();
			backStatic.cacheAsBitmap = true;
			levelArtArray.push(backStatic);
			var l2:* = new background2SkinClass();
			l2.cacheAsBitmap = true;
			l2.filters = [filter1];
			levelArtArray.push(l2);
			var l3:* = new background2SkinClass();
			l3.cacheAsBitmap = true;
			l3.width = (l3.width / 2);
			l3.height = (l3.height / 2);
			l3.filters = [filter1];
			levelArtArray.push(l3);
			var backgroundMainStage:* = new backgroundMainStageSkinClass();
			backgroundMainStage.cacheAsBitmap = true;
			levelArtArray.push(backgroundMainStage);
			backgroundMainStage.width = (backgroundMainStage.width * 10);
			backgroundMainStage.height = (backgroundMainStage.height * 10);
			parallaxWorld.borders = {x1:0, y1:0, x2:backgroundMainStage.width, y2:(backgroundMainStage.y + backgroundMainStage.height)};
			m_sprite.addChild(backgroundMainStage);
			m_sprite.addChild(renderCanvas);
			m_world.SetDebugDraw(dbgDraw);
			parallaxWorld.addPlane(backStatic, 0, 0, 0, true);
			parallaxWorld.addPlane(l3, 0, 150, 5000);
			parallaxWorld.addPlane(l2, 0, 100, 3000);
			parallaxWorld.addPlane(m_sprite, 0, 0, 0);
			parallaxWorld.pinit();
			var borderPath:Array = new Array("16089.255859,8304.230469", "46.091797,8304.230469", "46.091797,0.000000", "16089.255859,0.000000", "16089.255859,8304.230469");
			borderPath.reverse();
			createStaticEdge(borderPath, m_world, "boundary");
			var groundPath:Array = new Array("0.500000,5801.003906", "0.500000,5696.230469", "823.103516,5696.230469", "823.103516,5801.003906", "853.320313,5801.003906", "853.320313,5696.230469", "1869.132813,5696.230469", "1892.234375,5690.230469", "1935.734863,5690.230469", "1961.355469,5696.230469", "2615.789551,5696.230469", "2615.789551,5801.003906", "2646.006836,5801.003906", "2646.006836,5738.534180", "2656.223633,5738.534180", "2656.223633,5774.794434", "3003.823242,5774.794434", "3003.429199,5746.653320", "3300.670898,5746.653320", "3300.670898,5725.999512", "3417.604492,5726.230469", "3483.500000,5683.543945", "3783.869873,5774.794434", "4389.995117,5774.794434", "4389.995117,5738.534180", "4414.981445,5738.534180", "4414.981445,5774.794434", "4645.499512,5774.794434", "4804.782227,5727.512695", "4842.057129,5738.534180", "4893.374512,5696.230469", "5121.500000,5644.230469", "5242.781738,5665.512207", "5297.500000,5640.230469", "5398.781738,5669.512207", "5472.782227,5727.512695", "5796.307617,5692.097656", "6056.805664,5632.924805", "6237.375000,5774.794434", "6337.592285,5774.794434", "6337.460938,5738.534180", "6345.721680,5738.534180", "6345.853027,5798.967773", "6364.200195,5798.967773", "6364.200195,5696.230469", "7421.500488,5696.230469", "7455.500488,5688.230469", "7503.500000,5688.230469", "7543.500000,5696.230469", "8192.929688,5696.230469", "8192.929688,5801.003906", "8225.190430,5801.003906", "8225.190430,5696.230469", "8491.500000,5696.230469", "8513.500000,5689.230469", "8573.500000,5689.230469", "8605.500000,5696.230469", "10098.136719,5696.230469", "10098.136719,5801.003906", "10128.353516,5801.003906", "10128.353516,5738.534180", "10137.933594,5738.534180", "10138.070313,5774.794434", "10180.967773,5774.794434", "10180.967773,5767.517090", "10234.449219,5767.517090", "10234.449219,5750.048828", "10254.472656,5750.048828", "10254.472656,5733.454102", "10274.552734,5733.454102", "10274.552734,5712.229980", "10298.966797,5712.229980", "10298.833008,5700.230469", "10589.354492,5700.230469", "10589.354492,5665.527832", "10660.668945,5665.527832", "10660.668945,5705.578125", "10802.010742,5705.578125", "10802.010742,5719.527832", "10851.369141,5719.527832", "10851.233398,5738.534180", "11007.376953,5738.534180", "11007.376953,5721.756836", "11184.945313,5721.756836", "11184.945313,5708.931152", "11421.924805,5708.931152", "11547.329102,5727.865723", "11622.915039,5727.865723", "11622.915039,5750.386719", "11680.983398,5752.908691", "11680.983398,5761.428223", "11734.277344,5761.428223", "11734.277344,5727.865723", "11949.681641,5727.865723", "12096.895508,5702.931152", "12098.804688,5704.818848", "12073.200195,5709.977051", "12079.876953,5716.653809", "12074.456055,5727.017090", "12095.270508,5727.865723", "12095.270508,5774.794434", "12182.000977,5774.794434", "12181.876953,5738.534180", "12192.298828,5738.534180", "12192.298828,5801.003906", "12212.558594,5801.003906", "12212.558594,5696.230469", "13305.500000,5696.230469", "13341.503906,5687.230469", "13393.496094,5687.230469", "13429.501953,5696.230469", "14342.684570,5696.230469", "14342.818359,5801.003906", "14359.882813,5801.003906", "14359.749023,5696.230469", "14589.087891,5696.230469", "14608.581055,5691.230469", "14640.079102,5691.230469", "14662.584961,5696.230469", "15507.469727,5696.230469", "15507.498047,5687.010254", "15534.249023,5687.284180", "15551.503906,5696.230469", "15939.502930,5696.230469", "15939.502930,5690.570313", "15958.962891,5690.570313", "15958.962891,5696.230469", "16024.546875,5696.230469", "16049.721680,5705.299805", "16078.937500,5750.621094", "16110.447266,5767.460449", "16129.320313,5801.003906", "16227.759766,5801.003906", "16227.759766,6759.867676", "0.500000,6759.867676", "0.500000,5801.003906");
			createStaticEdge(groundPath, m_world, "ground");
			var sensor1Path:Array = new Array(new Point(6560.558105, 11672.230469), new Point(6432.558105, 584.230469));
			sensor1Path.reverse();
			userdata = new b2zUserData("sensor1", "sensor");
			CreateBox(sensor1Path, userdata, meterial.mlt_blank());
			var sensor2Path:Array = new Array(new Point(15880.337891, 11492.158203), new Point(15752.337891, 404.158691));
			sensor2Path.reverse();
			userdata = new b2zUserData("sensor2", "sensor");
			CreateBox(sensor2Path, userdata, meterial.mlt_blank());
			var sensor3Path:Array = new Array(new Point(15977.978516, 5774.794434), new Point(16226.830078, 5876.067383));
			sensor3Path.reverse();
			userdata = new b2zUserData("sensor3", "sensor");
			CreateBox(sensor3Path, userdata, meterial.mlt_blank());
			_currentRestorePoint = new b2Vec2(10, 175);
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			showTake();
		}
		override public function dynamicItems(){
		}
		override public function Update():void{
			super.Update();
			bike.update();
			parallaxWorld.update(bike.getCenter(), 150, 200);
			if (autoReset){
				resetPlayer();
				autoReset = false;
			};
		}
		override public function resetPlayer(){
			clearDynamicItems();
			dynamicItems();
			bike.remove();
			bike = new zmotorBike1(_currentRestorePoint, m_world, renderCanvas, m_drawScale);
			bike.create();
			_attemptCount++;
			showTake();
		}
		override public function responseSensor(item){
			switch (item.name){
				case "sensor1":
					_currentRestorePoint = new b2Vec2(220, 175);
					break;
				case "sensor2":
					if (((!(bike.IsFallen())) && (bike.standingUp()))){
						levelEnd();
					};
					break;
			};
			item.vergin = false;
		}

	}
}//package zahid.games.game59.levels 
Section 292
//level9_background2SkinClass (zahid.games.game59.levels.level9_background2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level9_background2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 293
//level9_backgroundMainStageSkinClass (zahid.games.game59.levels.level9_backgroundMainStageSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level9_backgroundMainStageSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 294
//level9_backStaticSkinClass (zahid.games.game59.levels.level9_backStaticSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class level9_backStaticSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 295
//mainmenu (zahid.games.game59.levels.mainmenu)
package zahid.games.game59.levels {
	import flash.events.*;
	import flash.display.*;
	import mx.core.*;
	import flash.filters.*;
	import flash.text.*;
	import com.boostworthy.animation.rendering.*;
	import com.boostworthy.animation.easing.*;
	import flash.net.*;

	public class mainmenu extends level {

		var bForward:DisplayObject;
		var numbItems;
		private var level2ThumbClass:Class;
		private var level4ThumbClass:Class;
		private var level6ThumbClass:Class;
		private var level8ThumbClass:Class;
		private var lockSkinClass:Class;
		private var levelBlankThumbClass:Class;
		var maxPosition;// = 3
		private var button2SkinClass:Class;
		var filter1:DropShadowFilter;
		var currentPosition;// = 0
		private var level10ThumbClass:Class;
		private var flimStripClass:Class;
		private var mainScreenBackClass:Class;
		var levelThumbArr:Array;
		private var level3ThumbClass:Class;
		private var level5ThumbClass:Class;
		private var level7ThumbClass:Class;
		private var level1ThumbClass:Class;
		private var level9ThumbClass:Class;
		var itemList:Sprite;
		var bBackward:DisplayObject;
		private var button1SkinClass:Class;

		public function mainmenu(){
			var levelBack:SpriteAsset;
			var thumb:*;
			var lockSkin:*;
			flimStripClass = mainmenu_flimStripClass;
			button1SkinClass = mainmenu_button1SkinClass;
			lockSkinClass = mainmenu_lockSkinClass;
			button2SkinClass = mainmenu_button2SkinClass;
			level1ThumbClass = mainmenu_level1ThumbClass;
			level2ThumbClass = mainmenu_level2ThumbClass;
			level3ThumbClass = mainmenu_level3ThumbClass;
			level4ThumbClass = mainmenu_level4ThumbClass;
			level5ThumbClass = mainmenu_level5ThumbClass;
			level6ThumbClass = mainmenu_level6ThumbClass;
			level7ThumbClass = mainmenu_level7ThumbClass;
			level8ThumbClass = mainmenu_level8ThumbClass;
			level9ThumbClass = mainmenu_level9ThumbClass;
			level10ThumbClass = mainmenu_level10ThumbClass;
			levelBlankThumbClass = mainmenu_levelBlankThumbClass;
			mainScreenBackClass = mainmenu_mainScreenBackClass;
			bBackward = new button2SkinClass();
			bForward = new button1SkinClass();
			itemList = new Sprite();
			levelThumbArr = [level1ThumbClass, level2ThumbClass, level3ThumbClass, level4ThumbClass, level5ThumbClass, level6ThumbClass, level7ThumbClass, level8ThumbClass, level9ThumbClass, level10ThumbClass];
			numbItems = levelThumbArr.length;
			filter1 = new DropShadowFilter();
			super();
			m_sprite.addChild(renderCanvas);
			Main.Stage.addChildAt(m_sprite, 0);
			loadScreen = new mainScreenBackClass();
			renderCanvas.addChild(loadScreen);
			renderCanvas.addChild(bBackward);
			bBackward.height = 100;
			bBackward.width = 20;
			bBackward.alpha = 0.5;
			bBackward.x = 10;
			bBackward.y = 250;
			bBackward.name = "back";
			bBackward.addEventListener(MouseEvent.ROLL_OVER, onRollOver);
			bBackward.addEventListener(MouseEvent.ROLL_OUT, onRollOut);
			bBackward.addEventListener(MouseEvent.MOUSE_DOWN, onRelease);
			renderCanvas.addChild(bForward);
			bForward.height = 100;
			bForward.width = 20;
			bForward.alpha = 0.5;
			bForward.x = 750;
			bForward.y = 250;
			bForward.name = "forth";
			bForward.addEventListener(MouseEvent.MOUSE_OVER, onRollOver);
			bForward.addEventListener(MouseEvent.MOUSE_OUT, onRollOut);
			bForward.addEventListener(MouseEvent.CLICK, onRelease);
			renderCanvas.addChild(itemList);
			var itemListMask:Sprite = new Sprite();
			itemListMask.graphics.beginFill(0, 1);
			itemListMask.graphics.drawRect(0, -10, 700, 120);
			itemListMask.graphics.endFill();
			renderCanvas.addChild(itemListMask);
			itemList.x = 40;
			itemList.y = 250;
			itemList.name = "itemList";
			itemListMask.x = itemList.x;
			itemListMask.y = itemList.y;
			itemList.mask = itemListMask;
			var i:* = 0;
			while (i < numbItems) {
				levelBack = new flimStripClass();
				itemList.addChild(levelBack);
				levelBack.x = (((itemList.numChildren - 1) * 100) + 10);
				levelBack.alpha = 0.5;
				if (i < Main.unlockpos){
					thumb = new (levelThumbArr[i]);
					levelBack.addChild(thumb);
					thumb.y = 20;
					thumb.x = 2;
					levelBack.addEventListener(MouseEvent.CLICK, onLevelRelease);
					levelBack.buttonMode = (levelBack.useHandCursor = true);
				} else {
					thumb = new levelBlankThumbClass();
					levelBack.addChild(thumb);
					thumb.y = 20;
					thumb.x = 2;
					lockSkin = new lockSkinClass();
					levelBack.addChild(lockSkin);
					lockSkin.x = ((thumb.width / 2) - (lockSkin.width / 2));
					lockSkin.y = 20;
					levelBack.addEventListener(MouseEvent.MOUSE_OUT, onRollOut);
					levelBack.addEventListener(MouseEvent.MOUSE_OVER, onRollOver);
				};
				i++;
			};
			var credit_mc:Sprite = new Sprite();
			credit_mc.graphics.beginFill(11020289, 0);
			credit_mc.graphics.drawRect(0, 0, 60, 25);
			credit_mc.x = 40;
			credit_mc.y = 360;
			renderCanvas.addChild(credit_mc);
			credit_mc.buttonMode = (credit_mc.useHandCursor = true);
			credit_mc.addEventListener(MouseEvent.CLICK, onCreditsBtn);
			var moreLink:Sprite = new Sprite();
			moreLink.graphics.beginFill(11020289, 0);
			moreLink.graphics.drawRect(0, 0, 350, 50);
			moreLink.x = 450;
			moreLink.y = 350;
			renderCanvas.addChild(moreLink);
			moreLink.buttonMode = (moreLink.useHandCursor = true);
			moreLink.addEventListener(MouseEvent.CLICK, onMoreLink);
		}
		function scrollList(p_offset:Number):void{
			gotoPosition((currentPosition + p_offset));
		}
		function onCreditsBtn(e){
			Main.loadLevel(11);
		}
		function onRelease(e){
			switch (e.target.name){
				case "back":
					scrollList(-1);
					break;
				case "forth":
					scrollList(1);
					break;
			};
		}
		function onRollOut(e){
			m_objAnimationManager.alpha(e.target, 0.5, 500, Transitions.CUBIC_OUT, RenderMethod.TIMER);
			e.target.filters = null;
		}
		function gotoPosition(p_position:Number):void{
			p_position = ((p_position < 0)) ? 0 : ((p_position > maxPosition)) ? maxPosition : p_position;
			if (p_position != currentPosition){
				currentPosition = p_position;
				m_objAnimationManager.move(itemList, (30 - (currentPosition * 100)), itemList.y, 1000, Transitions.ELASTIC_OUT, RenderMethod.TIMER);
			};
		}
		function onLevelRelease(e){
			var pos:* = (e.target.parent.getChildIndex(e.target) + 1);
			Main.loadLevel(pos);
		}
		override public function Update():void{
			super.Update();
		}
		function onMoreLink(e){
			var e = e;
			var url = "http://www.minijuegos.com";
			var request:URLRequest = new URLRequest(url);
			navigateToURL(request, "_blank");
			//unresolved jump
			var _slot1 = e;
			trace("Error occurred!");
		}
		function onRollOver(e){
			m_objAnimationManager.alpha(e.target, 1, 500, Transitions.CUBIC_OUT, RenderMethod.TIMER);
			e.target.filters = [filter1];
		}

	}
}//package zahid.games.game59.levels 
Section 296
//mainmenu_button1SkinClass (zahid.games.game59.levels.mainmenu_button1SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class mainmenu_button1SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 297
//mainmenu_button2SkinClass (zahid.games.game59.levels.mainmenu_button2SkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class mainmenu_button2SkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 298
//mainmenu_flimStripClass (zahid.games.game59.levels.mainmenu_flimStripClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class mainmenu_flimStripClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 299
//mainmenu_level10ThumbClass (zahid.games.game59.levels.mainmenu_level10ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level10ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 300
//mainmenu_level1ThumbClass (zahid.games.game59.levels.mainmenu_level1ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level1ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 301
//mainmenu_level2ThumbClass (zahid.games.game59.levels.mainmenu_level2ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level2ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 302
//mainmenu_level3ThumbClass (zahid.games.game59.levels.mainmenu_level3ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level3ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 303
//mainmenu_level4ThumbClass (zahid.games.game59.levels.mainmenu_level4ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level4ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 304
//mainmenu_level5ThumbClass (zahid.games.game59.levels.mainmenu_level5ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level5ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 305
//mainmenu_level6ThumbClass (zahid.games.game59.levels.mainmenu_level6ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level6ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 306
//mainmenu_level7ThumbClass (zahid.games.game59.levels.mainmenu_level7ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level7ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 307
//mainmenu_level8ThumbClass (zahid.games.game59.levels.mainmenu_level8ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level8ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 308
//mainmenu_level9ThumbClass (zahid.games.game59.levels.mainmenu_level9ThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_level9ThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 309
//mainmenu_levelBlankThumbClass (zahid.games.game59.levels.mainmenu_levelBlankThumbClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_levelBlankThumbClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 310
//mainmenu_lockSkinClass (zahid.games.game59.levels.mainmenu_lockSkinClass)
package zahid.games.game59.levels {
	import flash.display.*;
	import mx.core.*;

	public class mainmenu_lockSkinClass extends SpriteAsset {

		public var txt:DisplayObject;
		public var text_mc:DisplayObject;
		public var elements:DisplayObject;

	}
}//package zahid.games.game59.levels 
Section 311
//mainmenu_mainScreenBackClass (zahid.games.game59.levels.mainmenu_mainScreenBackClass)
package zahid.games.game59.levels {
	import mx.core.*;

	public class mainmenu_mainScreenBackClass extends BitmapAsset {

	}
}//package zahid.games.game59.levels 
Section 312
//zContactListener (zahid.games.game59.zContactListener)
package zahid.games.game59 {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.Math.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Common.*;

	public class zContactListener extends b2ContactListener {

		var thisParent;

		public function zContactListener(parent){
			thisParent = parent;
			super();
		}
		override public function Add(point:b2ContactPoint):void{
			thisParent.ContactAddHandler(point);
		}
		override public function Persist(point:b2ContactPoint):void{
			thisParent.ContactPersistHandler(point);
		}
		override public function Remove(point:b2ContactPoint):void{
			thisParent.ContactRemoveHandler(point);
		}
		override public function Result(point:b2ContactResult):void{
			thisParent.ContactResultHandler(point);
		}

	}
}//package zahid.games.game59 
Section 313
//Main (Main)
package {
	import flash.events.*;
	import flash.display.*;
	import General.*;
	import com.boostworthy.animation.management.*;
	import zahid.games.game59.levels.*;
	import com.boostworthy.animation.rendering.*;
	import com.boostworthy.animation.easing.*;

	public class Main extends MovieClip {

		private var soundHintClass:Class;
		public var m_input:Input;
		var SPLogo;
		protected var m_objAnimationManager:AnimationManager;
		private var SPLogoClass:Class;
		var soundHint;

		public static var pauseScreen = new Sprite();
		public static var infoWindow = new Sprite();
		public static var m_tests:Array = [mainmenu, level1, level10, level4, level9, level8, level2, level5, level6, level7, level3, credits];
		public static var unlockpos = 1;
		public static var takeScreen = new Sprite();
		public static var m_drawScale = 30;
		public static var gamesound:Boolean = true;
		public static var m_fpsCounter:FpsCounter = new FpsCounter();
		public static var endScreen = new Sprite();
		public static var Stage;
		public static var m_currTest:level;
		public static var m_currId:int = 0;

		public function Main():void{
			soundHintClass = Main_soundHintClass;
			SPLogoClass = Main_SPLogoClass;
			soundHint = new soundHintClass();
			SPLogo = new SPLogoClass();
			super();
			if (stage){
				init();
			} else {
				addEventListener(Event.ADDED_TO_STAGE, init);
			};
			addEventListener(Event.DEACTIVATE, windowNotActive);
		}
		function windowNotActive(e:Event):void{
			m_currTest.pausePlay(true);
		}
		public function update(e:Event):void{
			stage.focus = stage;
			if (!m_currTest.paused){
				if (((Input.isKeyPressed(82)) && (!(m_currTest.levelEndFlag)))){
					m_currTest.resetPlayer();
				};
				if (((Input.isKeyPressed(72)) && (!(m_currTest.levelEndFlag)))){
					m_currTest.showHideInforWindow();
				};
				if (Input.isKeyPressed(81)){
					loadLevel(0);
				};
				if (Input.isKeyPressed(67)){
					if (m_currTest.levelEndFlag){
						loadLevel((m_currTest._id + 1));
						//unresolved jump
					};
				};
				if (Input.isKeyPressed(83)){
					toggleSound();
					if (gamesound){
						soundHint.gotoAndStop(1);
					} else {
						soundHint.gotoAndStop(2);
					};
					soundHint.alpha = 1;
					m_objAnimationManager.alpha(soundHint, 0, 5000, Transitions.CUBIC_IN_AND_OUT, RenderMethod.TIMER);
				};
			};
			if (Input.isKeyPressed(80)){
				m_currTest.pausePlay();
			};
			m_currTest.Update();
			Input.update();
			m_fpsCounter.update();
			FRateLimiter.limitFrame(60);
		}
		private function init(e:Event=null):void{
			stage.frameRate = 30;
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			addEventListener(Event.ENTER_FRAME, update, false, 0, true);
			m_objAnimationManager = new AnimationManager();
			m_fpsCounter.x = 7;
			m_fpsCounter.y = 5;
			addChild(soundHint);
			soundHint.alpha = 0;
			soundHint.x = (soundHint.y = 20);
			Stage = this.stage;
			m_input = new Input(this);
			m_currTest = new (m_tests[m_currId]);
			Stage.addChild(infoWindow);
			Stage.addChild(takeScreen);
			Stage.addChild(endScreen);
			Stage.addChild(pauseScreen);
			Stage.addChild(SPLogo);
		}

		public static function toggleSound(){
			gamesound = !(gamesound);
		}
		public static function loadLevel(pos){
			trace(pos);
			m_currTest.unloadLevel();
			m_currId++;
			m_currId = ((m_currId + m_tests.length) % m_tests.length);
			m_currTest = new (m_tests[pos]);
		}

	}
}//package 
Section 314
//Main_soundHintClass (Main_soundHintClass)
package {
	import mx.core.*;

	public class Main_soundHintClass extends MovieClipAsset {

	}
}//package 
Section 315
//Main_SPLogoClass (Main_SPLogoClass)
package {
	import mx.core.*;
	import flash.utils.*;

	public class Main_SPLogoClass extends MovieClipLoaderAsset {

		public var dataClass:Class;

		private static var bytes:ByteArray = null;

		public function Main_SPLogoClass(){
			dataClass = Main_SPLogoClass_dataClass;
			super();
			initialWidth = (15400 / 20);
			initialHeight = (8000 / 20);
		}
		override public function get movieClipData():ByteArray{
			if (bytes == null){
				bytes = ByteArray(new dataClass());
			};
			return (bytes);
		}

	}
}//package 
Section 316
//Main_SPLogoClass_dataClass (Main_SPLogoClass_dataClass)
package {
	import mx.core.*;

	public class Main_SPLogoClass_dataClass extends ByteArrayAsset {

	}
}//package 
Section 317
//MochiBot (MochiBot)
package {
	import flash.display.*;
	import flash.system.*;
	import flash.net.*;

	public dynamic class MochiBot extends Sprite {

		public function MochiBot(){
			super();
		}
		public static function track(parent:Sprite, tag:String):MochiBot{
			if (Security.sandboxType == "localWithFile"){
				return (null);
			};
			var self:MochiBot = new (MochiBot);
			parent.addChild(self);
			Security.allowDomain("*");
			Security.allowInsecureDomain("*");
			var server:String = "http://core.mochibot.com/my/core.swf";
			var lv:URLVariables = new URLVariables();
			lv["sb"] = Security.sandboxType;
			lv["v"] = Capabilities.version;
			lv["swfid"] = tag;
			lv["mv"] = "8";
			lv["fv"] = "9";
			var url:String = self.root.loaderInfo.loaderURL;
			if (url.indexOf("http") == 0){
				lv["url"] = url;
			} else {
				lv["url"] = "local";
			};
			var req:URLRequest = new URLRequest(server);
			req.contentType = "application/x-www-form-urlencoded";
			req.method = URLRequestMethod.POST;
			req.data = lv;
			var loader:Loader = new Loader();
			self.addChild(loader);
			loader.load(req);
			return (self);
		}

	}
}//package 
Section 318
//PreloaderSP (PreloaderSP)
package {
	import flash.events.*;
	import flash.display.*;
	import mochi.as3.*;
	import flash.utils.*;
	import General.*;

	public dynamic class PreloaderSP extends MovieClip {

		private var did_load:Boolean;

		public static var GAME_OPTIONS:Object = {id:"751d2e6f2da54e30", res:"779x400"};
		public static var MAIN_CLASS:String = "Main";

		public function PreloaderSP(){
			var k:String;
			super();
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			MochiBot.track(this, "9195c84c");
			var f:Function = function (ev:IOErrorEvent):void{
			};
			loaderInfo.addEventListener(IOErrorEvent.IO_ERROR, f);
			var opts:Object = {};
			for (k in GAME_OPTIONS) {
				opts[k] = GAME_OPTIONS[k];
			};
			opts.ad_started = function ():void{
				did_load = true;
			};
			opts.ad_finished = function ():void{
				var mainClass:Class = Class(getDefinitionByName(MAIN_CLASS));
				var app:Object = new (mainClass);
				addChild((app as DisplayObject));
			};
			opts.clip = this;
			MochiAd.showPreGameAd(opts);
		}
	}
}//package