struct Element
	{
		Element()       :a(0)  {Cout()<<"*";}
		Element(int _a) :a(_a) {Cout()<<"+";}
		~Element()             {Cout()<<".";}
		Element & operator= (const Element&op) {a=op.a; Cout()<<"="; return *this;}
		int a;
	};
	QuickDeque<Element> vec;
	static Element elm(0);
	for (int i=0;i<10;++i)
	{
		elm.a = i;
		vec.AddTail(elm);
	}

template<class T> class QuickDeque
{
public:
	QuickDeque(int cap = 10) :capacity(0), data(NULL), start(0), count(0) {ASSERT(cap > 0); AddAlloc(cap);}
	~QuickDeque() {DeAlloc(); }
	
	void AddTail(const T&t) {if (count >= capacity) AddAlloc(count); int offs=start+count; if (offs >= capacity) offs-=capacity; *((T *) &data[offs*sizeof(T)]) = t; ++count;}
	void DropHead(T &t) {ASSERT(count > 0); t = *((T *) &data[start*sizeof(T)]); if (++start == capacity) start=0; --count;}
	T &operator[] (int n) {ASSERT(n>=0 && n<count); int offs=start+n; if (offs >= capacity) offs-=capacity; return *((T *) &data[offs*sizeof(T)]);}
	int GetCount() {return count;}
	
private:
	void AddAlloc(int capacityAdd)
	{
		ASSERT(capacityAdd >= 0);
		int capacityNew = capacity+capacityAdd;
		byte *newData = new byte[capacityNew*sizeof(T)];
		memcpy(&newData[0], &data[start*sizeof(T)], (capacity-start)*sizeof(T));
		memcpy(&newData[(capacity-start)*sizeof(T)], &data[0], start*sizeof(T));
		for (int i=count; i<capacityNew; ++i)
			new (&newData[i*sizeof(T)]) T();
		
		if (data)
			delete[] data;
		start    = 0;
		data     = newData;
		capacity = capacityNew;
	}
	
	void DeAlloc()
	{
		for (int i=0; i<capacity; ++i)
			((T *) &data[i*sizeof(T)])->T::~T();
		if (data)
			delete[] data;
	}
	
	int   capacity;
	byte *data;
	int   start,
	      count;
};

	T&       AddHead(T *newt)              { bv.AddHead(newt); return *newt; }
	T&       AddTail(T *newt)              { bv.AddTail(newt); return *newt; }
	template <class TT> TT& CreateHead()   { TT *q = new TT; bv.AddHead(q); return *q; }
	template <class TT> TT& CreateTail()   { TT *q = new TT; bv.AddTail(q); return *q; }
	T       *DetachHead()                  { T *q = (T*) bv.Head(); bv.DropHead(); return q; }
	T       *DetachTail()                  { T *q = (T*) bv.Tail(); bv.DropTail(); return q; }