#include <iostream>
using namespace std;

template <int I, int P>
class is_prime_aux
{
public:
	enum { prim = ( P % I > 0 ) && is_prime_aux< (I * I > P ? 0 : I + 2 ), P >::prim };
};

template <int P>
class is_prime_aux<0,P>
{
public:
	enum { prim = true };
};

template <int P>
class is_prime_aux<3,P>
{
public:
	enum { prim = true };
};

template <int N>
class is_prime
{
public:
	enum { prim = ( N % 2? is_prime_aux<3,N>::prim : false ) };
};

template <>
class is_prime<2>
{
public:
	enum { prim = true } ;
};


template <int N, int Y>
class is_divisible
{
public:
	enum { X      = ( N % Y == 0 ) ? N / Y : N, 
	       result = ( N > X ) || is_divisible< X, ( N > X )? Y : 0 >::result,
	       rest = is_divisible< X, ( N > X )? Y : 0 >::rest };

	static inline void f() { 
	    if ( result ) {
	     	cout << Y << " "; 
	     	is_divisible< X, (N > X)? Y : 0>::f();
	    }
	}
};

template <int N>
class is_divisible<N,0>
{
public:
	enum {  rest = N,
		result = false };
	static inline void f() { }
};

template <int N, int Y>
class find_primes
{
public:
	enum {  rest  = is_divisible< N, is_prime<Y>::prim? Y : 0 >::rest,
		next  = find_primes< rest, Y + 1 >::next };
	static inline void print(){
		is_divisible< N, is_prime<Y>::prim? Y : 0 >::f(); 
		find_primes< rest, Y + 1 >::print(); }
	};

template <int Y>
class find_primes<1,Y>
{
public:
	enum { next = 1 };
	static inline void print() {}
};

template <int P>
class primes
{
public:
	static inline void print() { find_primes<P,2>::print(); }
};

int main()
{
	primes<1500>::print();
	cout << endl;
	primes<573>::print();
	cout << endl;
	return 0;
}