/physcomparison/src/app/cx/FastList.hx

Large files files are truncated, but you can click here to view the full file

package cx;



import nape.Array2; import nape.Collide; import nape.Config; import nape.Constraint; import nape.Dynamics; import nape.FastMath; import nape.Geom; import nape.PhysAux; import nape.PhysObj; import nape.Shape; import nape.Space; import nape.Tools; import nape.VecMath; import cx.Algorithm; import cx.Allocator; import cx.MixList;







class CxFastList_PhysObj {

	

	private var head:CxFastNode_PhysObj;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:PhysObj) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_PhysObj();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():PhysObj {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_PhysObj(ret);

		return retv;

	}

	public inline function remove(obj:PhysObj):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_PhysObj,cur:CxFastNode_PhysObj):CxFastNode_PhysObj {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_PhysObj(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_PhysObj,cur:CxFastNode_PhysObj,n:Int):CxFastNode_PhysObj {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_PhysObj(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_PhysObj();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:PhysObj) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_ObjArb {

	

	private var head:CxFastNode_ObjArb;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:ObjArb) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_ObjArb();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():ObjArb {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_ObjArb(ret);

		return retv;

	}

	public inline function remove(obj:ObjArb):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_ObjArb,cur:CxFastNode_ObjArb):CxFastNode_ObjArb {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_ObjArb(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_ObjArb,cur:CxFastNode_ObjArb,n:Int):CxFastNode_ObjArb {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_ObjArb(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_ObjArb();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:ObjArb) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Arbiter {

	

	private var head:CxFastNode_Arbiter;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Arbiter) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Arbiter();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Arbiter {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Arbiter(ret);

		return retv;

	}

	public inline function remove(obj:Arbiter):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Arbiter,cur:CxFastNode_Arbiter):CxFastNode_Arbiter {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Arbiter(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Arbiter,cur:CxFastNode_Arbiter,n:Int):CxFastNode_Arbiter {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Arbiter(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Arbiter();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Arbiter) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Contact {

	

	private var head:CxFastNode_Contact;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Contact) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Contact();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Contact {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Contact(ret);

		return retv;

	}

	public inline function remove(obj:Contact):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Contact,cur:CxFastNode_Contact):CxFastNode_Contact {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Contact(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Contact,cur:CxFastNode_Contact,n:Int):CxFastNode_Contact {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Contact(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Contact();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Contact) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_GeomPoly {

	

	private var head:CxFastNode_GeomPoly;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:GeomPoly) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_GeomPoly();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():GeomPoly {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_GeomPoly(ret);

		return retv;

	}

	public inline function remove(obj:GeomPoly):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_GeomPoly,cur:CxFastNode_GeomPoly):CxFastNode_GeomPoly {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_GeomPoly(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_GeomPoly,cur:CxFastNode_GeomPoly,n:Int):CxFastNode_GeomPoly {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_GeomPoly(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_GeomPoly();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:GeomPoly) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Constraint {

	

	private var head:CxFastNode_Constraint;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Constraint) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Constraint();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Constraint {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Constraint(ret);

		return retv;

	}

	public inline function remove(obj:Constraint):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Constraint,cur:CxFastNode_Constraint):CxFastNode_Constraint {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Constraint(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Constraint,cur:CxFastNode_Constraint,n:Int):CxFastNode_Constraint {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Constraint(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Constraint();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Constraint) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Body {

	

	private var head:CxFastNode_Body;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Body) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Body();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Body {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Body(ret);

		return retv;

	}

	public inline function remove(obj:Body):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Body,cur:CxFastNode_Body):CxFastNode_Body {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Body(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Body,cur:CxFastNode_Body,n:Int):CxFastNode_Body {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Body(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Body();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Body) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Particle {

	

	private var head:CxFastNode_Particle;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Particle) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Particle();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Particle {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Particle(ret);

		return retv;

	}

	public inline function remove(obj:Particle):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Particle,cur:CxFastNode_Particle):CxFastNode_Particle {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Particle(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Particle,cur:CxFastNode_Particle,n:Int):CxFastNode_Particle {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Particle(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Particle();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Particle) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Group {

	

	private var head:CxFastNode_Group;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Group) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Group();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Group {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Group(ret);

		return retv;

	}

	public inline function remove(obj:Group):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Group,cur:CxFastNode_Group):CxFastNode_Group {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Group(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Group,cur:CxFastNode_Group,n:Int):CxFastNode_Group {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Group(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Group();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Group) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Properties {

	

	private var head:CxFastNode_Properties;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Properties) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Properties();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Properties {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Properties(ret);

		return retv;

	}

	public inline function remove(obj:Properties):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Properties,cur:CxFastNode_Properties):CxFastNode_Properties {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Properties(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Properties,cur:CxFastNode_Properties,n:Int):CxFastNode_Properties {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Properties(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Properties();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Properties) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Shape {

	

	private var head:CxFastNode_Shape;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Shape) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Shape();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Shape {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Shape(ret);

		return retv;

	}

	public inline function remove(obj:Shape):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Shape,cur:CxFastNode_Shape):CxFastNode_Shape {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Shape(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Shape,cur:CxFastNode_Shape,n:Int):CxFastNode_Shape {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Shape(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Shape();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Shape) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Arbiter_false_false_true_true_Shape_Shape {

	

	private var head:CxFastNode_Arbiter_false_false_true_true_Shape_Shape;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Arbiter_false_false_true_true_Shape_Shape) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Arbiter_false_false_true_true_Shape_Shape();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Arbiter_false_false_true_true_Shape_Shape {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Arbiter_false_false_true_true_Shape_Shape(ret);

		return retv;

	}

	public inline function remove(obj:Arbiter_false_false_true_true_Shape_Shape):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Arbiter_false_false_true_true_Shape_Shape,cur:CxFastNode_Arbiter_false_false_true_true_Shape_Shape):CxFastNode_Arbiter_false_false_true_true_Shape_Shape {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Arbiter_false_false_true_true_Shape_Shape(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Arbiter_false_false_true_true_Shape_Shape,cur:CxFastNode_Arbiter_false_false_true_true_Shape_Shape,n:Int):CxFastNode_Arbiter_false_false_true_true_Shape_Shape {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Arbiter_false_false_true_true_Shape_Shape(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Arbiter_false_false_true_true_Shape_Shape();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Arbiter_false_false_true_true_Shape_Shape) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Arbiter_false_false_true_false_Shape_Particle {

	

	private var head:CxFastNode_Arbiter_false_false_true_false_Shape_Particle;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Arbiter_false_false_true_false_Shape_Particle) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Arbiter_false_false_true_false_Shape_Particle();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Arbiter_false_false_true_false_Shape_Particle {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Arbiter_false_false_true_false_Shape_Particle(ret);

		return retv;

	}

	public inline function remove(obj:Arbiter_false_false_true_false_Shape_Particle):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Arbiter_false_false_true_false_Shape_Particle,cur:CxFastNode_Arbiter_false_false_true_false_Shape_Particle):CxFastNode_Arbiter_false_false_true_false_Shape_Particle {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Arbiter_false_false_true_false_Shape_Particle(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Arbiter_false_false_true_false_Shape_Particle,cur:CxFastNode_Arbiter_false_false_true_false_Shape_Particle,n:Int):CxFastNode_Arbiter_false_false_true_false_Shape_Particle {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Arbiter_false_false_true_false_Shape_Particle(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Arbiter_false_false_true_false_Shape_Particle();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Arbiter_false_false_true_false_Shape_Particle) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Arbiter_true_true_true_true_Shape_Shape {

	

	private var head:CxFastNode_Arbiter_true_true_true_true_Shape_Shape;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Arbiter_true_true_true_true_Shape_Shape) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Arbiter_true_true_true_true_Shape_Shape();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Arbiter_true_true_true_true_Shape_Shape {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Arbiter_true_true_true_true_Shape_Shape(ret);

		return retv;

	}

	public inline function remove(obj:Arbiter_true_true_true_true_Shape_Shape):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Arbiter_true_true_true_true_Shape_Shape,cur:CxFastNode_Arbiter_true_true_true_true_Shape_Shape):CxFastNode_Arbiter_true_true_true_true_Shape_Shape {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Arbiter_true_true_true_true_Shape_Shape(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Arbiter_true_true_true_true_Shape_Shape,cur:CxFastNode_Arbiter_true_true_true_true_Shape_Shape,n:Int):CxFastNode_Arbiter_true_true_true_true_Shape_Shape {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Arbiter_true_true_true_true_Shape_Shape(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Arbiter_true_true_true_true_Shape_Shape();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Arbiter_true_true_true_true_Shape_Shape) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_Arbiter_true_true_true_false_Shape_Particle {

	

	private var head:CxFastNode_Arbiter_true_true_true_false_Shape_Particle;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:Arbiter_true_true_true_false_Shape_Particle) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_Arbiter_true_true_true_false_Shape_Particle();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():Arbiter_true_true_true_false_Shape_Particle {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_Arbiter_true_true_true_false_Shape_Particle(ret);

		return retv;

	}

	public inline function remove(obj:Arbiter_true_true_true_false_Shape_Particle):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_Arbiter_true_true_true_false_Shape_Particle,cur:CxFastNode_Arbiter_true_true_true_false_Shape_Particle):CxFastNode_Arbiter_true_true_true_false_Shape_Particle {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_Arbiter_true_true_true_false_Shape_Particle(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_Arbiter_true_true_true_false_Shape_Particle,cur:CxFastNode_Arbiter_true_true_true_false_Shape_Particle,n:Int):CxFastNode_Arbiter_true_true_true_false_Shape_Particle {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_Arbiter_true_true_true_false_Shape_Particle(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_Arbiter_true_true_true_false_Shape_Particle();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:Arbiter_true_true_true_false_Shape_Particle) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_UniformCell {

	

	private var head:CxFastNode_UniformCell;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:UniformCell) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_UniformCell();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():UniformCell {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_UniformCell(ret);

		return retv;

	}

	public inline function remove(obj:UniformCell):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_UniformCell,cur:CxFastNode_UniformCell):CxFastNode_UniformCell {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_UniformCell(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_UniformCell,cur:CxFastNode_UniformCell,n:Int):CxFastNode_UniformCell {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_UniformCell(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_UniformCell();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:UniformCell) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}class CxFastList_UniformSleepCell {

	

	private var head:CxFastNode_UniformSleepCell;

	private var alloc:Allocator;

	

	

	

	public function new(?a:Allocator) {

		alloc = if(a==null) Allocator.GLOBAL else a;

	}

	

	

	

	

	public inline function add(o:UniformSleepCell) {

		var temp =  {

		var ret = alloc.CxAlloc_CxFastNode_UniformSleepCell();

		ret.elt = o;

		ret;

	};

		temp.next = begin();

		 head=temp;

	}

	public inline function pop():UniformSleepCell {

		var ret = begin();

		 head=ret.next;

		var retv = ret.elem();

		 alloc.CxFree_CxFastNode_UniformSleepCell(ret);

		return retv;

	}

	public inline function remove(obj:UniformSleepCell):Bool {

		var pre = null;

		var cur = begin();

		var ret = false;

		while(cur!=end()) {

			if(cur.elem()==obj) {

				cur = erase(pre,cur);

				ret = true;

				break;

			}

			pre = cur;

			cur = cur.next;

		}

		return ret;

	}

	public inline function erase(pre:CxFastNode_UniformSleepCell,cur:CxFastNode_UniformSleepCell):CxFastNode_UniformSleepCell {

		var old = cur; cur = cur.next;

		if(pre==null)  head=cur;

		else          pre.next = cur;

		 {};

		 alloc.CxFree_CxFastNode_UniformSleepCell(old);

		return cur;

	}

	public inline function splice(pre:CxFastNode_UniformSleepCell,cur:CxFastNode_UniformSleepCell,n:Int):CxFastNode_UniformSleepCell {

		while(n-->0 && cur!=end())

			cur = erase(pre,cur);

		return cur;

	}

	public inline function clear() {

		if(true) {

			while(!empty()) {

				var old = begin();

				 head=old.next;

				 {};

				 alloc.CxFree_CxFastNode_UniformSleepCell(old);

			}

		}else  head=end();

	}

	public inline function reverse() {

		var tmp = new CxFastList_UniformSleepCell();

		while(!empty())

			tmp.add(pop());

		 head=tmp.begin();

	}

	

	public inline function empty():Bool return begin()==end()

	public inline function size():Int {

		var cnt = 0;

		var cur = begin();

		while(cur!=end()) { cnt++; cur=cur.next; }

		return cnt;

	}

	public inline function has(obj:UniformSleepCell) return  ({

	var ret = false;

	  {

	var cxiterator = this.begin();

	while(cxiterator != this.end()) {

		var cxite = cxiterator.elem();

		{

			

			{

		if(cxite==obj) {

			ret = true;

			break;

		}

	};

		}

		cxiterator = cxiterator.next;

	}

};

	ret;

})

	

	public inline function front() return begin().elem()

	

	public inline function back() {

		var ret = begin();

		var cur = ret;

		while(cur!=end()) { ret = cur; cur = cur.next; }

		return ret.elem();

	}

	

	public inline function at(ind:Int) {

		var ret = begin();

		while(ind-->0) ret = ret.next;

		return ret.elem();

	}



	

	

	

	public inline function begin() return head

	public inline function end  () return null

	

	

	

	

	

}







class CxFastNode_PhysObj {

	public var elt:PhysObj;

	public var next:CxFastNode_PhysObj;

	

	public function new() {}

	

	public inline function elem ():PhysObj return elt

}class CxFastNode_ObjArb {

	public var elt:ObjArb;

	public var next:CxFastNode_ObjArb;

	

	public function new() {}

	

	public inline function elem ():ObjArb return elt

}class CxFastNode_Arbiter {

	public var elt:Arbiter;

	public var next:CxFastNode_Arbiter;

	

	public function new() {}

	

	public inline function elem ():Arbiter return elt

}class CxFastNode_Contact {

	public var elt:Contact;

	public var next:CxFastNode_Contact;

	

	public function new() {}

	

	public inline function elem ():Contact return elt

}class CxFastNode_GeomPoly {

	public var elt:GeomPoly;

	public var next:CxFastNode_GeomPoly;

	

	public function new() {}

	

	public inline function elem ():GeomPoly return elt

}class CxFastNode_Constraint {

	public var elt:Constraint;

	public var next:CxFastNode_Constraint;

	

	public function new() {}

	

	public inline function elem ():Constraint return elt

}class CxFastNode_Body {

	public var elt:Body;

	public var next:CxFastNode_Body;

	

	public function new() {}

	

	public inline function elem ():Body return elt

}class CxFastNode_Particle {

	public var elt:Particle;

	public var next:CxFastNode_Particle;

	

	public function new() {}

	

	public inline function elem ():Particle return elt

}class CxFastNode_Group {

	public var elt:Group;

	public var next:CxFastNode_Group;

	

	public function new() {}

	

	public inline function elem ():Group return elt

}class CxFastNode_Properties {

	public var elt:Properties;

	public var next:CxFastNode_Properties;

	

	public function new() {}

	

	public inline function elem ():Properties return elt

}class CxFastNode_Callback {

	public var elt:Callback;

	public var next:CxFastNode_Callback;

	

	public function new() {}

	

	public inline function elem ():Callback return elt

}class CxFastNode_Shape {

	public var elt:Shape;

	public var next:CxFastNode_Shape;

	

	public function new() {}

	

	public inline function elem ():Shape return elt

}class CxFastNode_Arbiter_false_false_true_true_Shape_Shape {

	public var elt:Arbiter_false_false_true_true_Shape_Shape;

	public var next:CxFastNode_Arbiter_false_false_true_true_Shape_Shape;

	

	public function new() {}

	

	public inline function elem ():Arbiter_false_false_true_true_Shape_Shape return elt

}class CxFastNode_Arbiter_false_false_true_false_Shape_Particle {

	public var elt:Arbiter_false_false_true_false_Shape_Particle;

	public var next:CxFastNode_Arbiter_false_false_true_false_Shape_Particle;

	

	public function new() {}

	

	public inline function elem ():Arbiter_false_false_true_false_Shape_Particle return elt

}class CxFastNode_Arbiter_true_true_t…