template <typename T, unsigned unrollCount = 0>
class ArrayAssignmentUnroller
{
	void Assign ( T* Dest, T* Source ) {}
};

template <typename T>
class ArrayAssignmentUnroller<T, 1>
{
public:
	void Assign ( T* Dest, T* Source ) 
	{ 
		Dest[0] = Source[0]; 
	}
};

template <typename T>
class ArrayAssignmentUnroller<T, 2>
{
public:
	void Assign ( T* Dest, T* Source ) 
	{ 
		Dest[0] = Source[0]; 
		Dest[1] = Source[1]; 
	}
};

template <typename T>
class ArrayAssignmentUnroller<T, 3>
{
public:
	void Assign ( T* Dest, T* Source ) 
	{ 
		Dest[0] = Source[0]; 
		Dest[1] = Source[1]; 
		Dest[2] = Source[2]; 
	}
};

template <typename T>
class ArrayAssignmentUnroller<T, 4>
{
public:
	void Assign ( T* Dest, T* Source ) 
	{ 
		Dest[0] = Source[0]; 
		Dest[1] = Source[1]; 
		Dest[2] = Source[2]; 
		Dest[3] = Source[3]; 
	}
};

template <typename T>
class ArrayAssignmentUnroller<T, 5>
{
public:
	void Assign ( T* Dest, T* Source ) 
	{ 
		Dest[0] = Source[0]; 
		Dest[1] = Source[1]; 
		Dest[2] = Source[2];
		Dest[3] = Source[3]; 
		Dest[4] = Source[4]; 
	}
};

template<typename T>
class UnrollerWrap
{
public:
	void AssignmentIterate(T* dest, T* source, unsigned size)
	{
		int count = 0;
		while( count < size )
		{
			switch( (size - count) % 5)
			{
			case 0:
				r5.Assign(&dest[count], &source[count]);
				count += 5;
				break;
			case 1:
				r1.Assign(&dest[count], &source[count]);
				count += 4;
				break;
			case 2:
				r2.Assign(&dest[count], &source[count]);
				count += 3;
				break;
			case 3:
				r3.Assign(&dest[count], &source[count]);
				count += 2;
				break;
			case 4:
				r4.Assign(&dest[count], &source[count]);
				count += 1;
				break;
			}
                }
	}

private:
	ArrayAssignmentUnroller<T, 1> r1;
	ArrayAssignmentUnroller<T, 2> r2;
	ArrayAssignmentUnroller<T, 3> r3;
	ArrayAssignmentUnroller<T, 4> r4;
	ArrayAssignmentUnroller<T, 5> r5;
};


//Values here are arbitary, just for show.
int _tmain(int argc, _TCHAR* argv[])
{
	int i[] = {1,2,3,1,2,5,5,8,7,6,8,9,9,7,5,4,2,21,6,3,458,4,2,2,3,5,4,8,7,5,9,78,7,5,1,2,56,321};
	int o[30];
	UnrollerWrap<int> uw;
	uw.AssignmentIterate(&o[0], &i[0], 20);
	return 0;

template <class T, int n, int i> struct unrolled {	enum {CTR = i+1};	inline static void assign(T *a, const T *b) { a = b; unrolled<T, n, CTR>::assign(a, b); }};template <class T, int n> struct unrolled<T, n, n> {	inline static void assign(T *a, const T *b) {}};// ...int dest[5], source[5];// ...unrolled::assign<int, sizeof(dest)/sizeof(dest[0]), 0>(dest, source);

int main(){    int x = 0;    char array1[8] = "1234567";    char array2[8] = "0000000";    // This line makes sure the compiler doesn't initialize the arrays    // to be equal. (Down with compiler optimization!)    cout << array1 << ' ' << array2 << endl;    // TRY 1    asm("# COPY START");    int i = 8;    while( i-- )        array2 = array1;    asm("# COPY END");    // TRY 2    asm(        // array2[0...3] = array1[0...3]        "  \t movl (%0), %%eax \n"        "\t\t movl %%eax, (%1) \n"        "\n # Increment the pointers by one long word. \n"        "\t\t addl $4, %0      \n"        "\t\t addl $4, %1      \n"        // array2[4...7] = array1[4...7]        "\t\t movl (%0), %%eax \n"        "\t\t movl %%eax, (%1) \n"        :        : "rS"(array1), "rD"(array2)        : "eax"    );        // TRY 3    asm("# COPY START");    memcpy( array2, array1, 8 );    asm("# COPY END");    cout << array1 << ' ' << array2 << endl;        cout << endl;}

/APP # 18 "testing.cpp" 1	# COPY START # 0 "" 2/NO_APP	movb	-21(%ebp), %al	movb	%al, -29(%ebp)	movb	-22(%ebp), %al	movb	%al, -30(%ebp)	movb	-23(%ebp), %al	movb	%al, -31(%ebp)	movb	-24(%ebp), %al	movb	%al, -32(%ebp)	movb	-25(%ebp), %al	movb	%al, -33(%ebp)	movb	-26(%ebp), %al	movb	%al, -34(%ebp)	movb	-27(%ebp), %al	movb	%al, -35(%ebp)	movb	-28(%ebp), %al	movb	%al, -36(%ebp)/APP # 22 "testing.cpp" 1	# COPY END # 0 "" 2/NO_APP

	movl	-25(%ebp), %eax	movl	-21(%ebp), %edx	movl	%eax, -33(%ebp)	movl	%edx, -29(%ebp)

template <typename T>class ArrayAssignmentUnroller<char, 4>{public:	void Assign ( char* Dest, char* Source ) 	{ 		Dest[0] = Source[0]; 		Dest[1] = Source[1]; 		Dest[2] = Source[2]; 		Dest[3] = Source[3]; 	}};

	movl	-24(%ebp), %ecx	movl	-72(%ebp), %edi	movl	-68(%ebp), %esi	rep movsb # This is the only instruction that takes any time at all.

template <typename T, unsigned unrollCount>class ArrayAssignmentUnroller{public:	static inline void Assign ( T* Dest, T* Source ) 	{		memcpy( Dest, Source, CopySize);	}	static unsigned CopySize;};template <typename T, unsigned unrollCount> unsigned ArrayAssignmentUnroller<T, unrollCount>::CopySize = sizeof(T) * unrollCount;template<typename T>class UnrollerWrap{public:	inline void AssignmentIterate(T* dest, T* source, unsigned size)	{		unsigned count = (size) % 10;				switch( count )		{		case 0:			r10.Assign(&dest[0], &source[0]);			count = 10;			break;		case 1:			r1.Assign(&dest[0], &source[0]);			break;		case 2:			r2.Assign(&dest[0], &source[0]);			break;		case 3:			r3.Assign(&dest[0], &source[0]);			break;		case 4:			r4.Assign(&dest[0], &source[0]);			break;		case 5:			r5.Assign(&dest[0], &source[0]);			break;		case 6:			r6.Assign(&dest[0], &source[0]);			break;		case 7:			r7.Assign(&dest[0], &source[0]);			break;		case 8:			r8.Assign(&dest[0], &source[0]);			break;		case 9:			r9.Assign(&dest[0], &source[0]);			break;		}				while( count < size )		{			r10.Assign(&dest[count], &source[count]);			count += 10;		}					}private:	ArrayAssignmentUnroller<T, 1> r1;	ArrayAssignmentUnroller<T, 2> r2;	ArrayAssignmentUnroller<T, 3> r3;	ArrayAssignmentUnroller<T, 4> r4;	ArrayAssignmentUnroller<T, 5> r5;	ArrayAssignmentUnroller<T, 6> r6;	ArrayAssignmentUnroller<T, 7> r7;	ArrayAssignmentUnroller<T, 8> r8;	ArrayAssignmentUnroller<T, 9> r9;	ArrayAssignmentUnroller<T, 10> r10;};