/*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the  Free Software  Foundation, either  version 3 of the License, or
(at your option) any later version.

This  program  is  distributed  in the hope that  it  will be useful,
but  WITHOUT ANY  WARRANTY; without  even  the  implied  warranty  of
MERCHANTABILITY  or FITNESS  FOR  A  PARTICULAR  PURPOSE. See the GNU 
General Public License for more details.

You should  have received  a copy  of the  GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

 Author:         Marco Vitetta
 E-mail:         <vito3200@hotmail.it>
 WebSite:        http://ervito.altervista.org
*/

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int numerical_permutations(long long int NUMBER_OF_ARGUMENTS,...);
int prime(long long int VALUE, long long int *PRIMES_ARRAY,...);
long long int *primes_below(long long int MAX_VALUE,long long int *PRIMES_NUMBER);
void rotate(char *string);
int main()
{
	char string[7];
	int is_circular,length,rotations_number;
	long long int *circulars_array=NULL,circulars_number=0,index1=0,index2,number,*primes_array,primes_number=0,rotations_array[6];

	primes_array=primes_below(1000000,&primes_number);
	for(;index1<primes_number;is_circular=rotations_number=0,index1++)
	{
		sprintf(string,"%lli",primes_array[index1]);
		length=strlen(string);
		rotations_array[0]=primes_array[index1];
		while(is_circular==0 && rotations_number++<length)
		{
			rotate(string);
			number=atoll(string);
			if(prime(number,primes_array,primes_number))
				rotations_array[rotations_number]=number;
			else
				is_circular=1;
		}
		if(is_circular==0)
		{
			for(index2=0;circulars_array!=NULL && index2<circulars_number && primes_array[index1]!=circulars_array[index2];index2++);
			if(index2==circulars_number)
			{
				circulars_array=realloc(circulars_array,sizeof(long long int)*(circulars_number+length));
				for(index2=0;index2<length;index2++)
					circulars_array[circulars_number+index2]=rotations_array[index2];
				circulars_number+=length;
			}
		}
	}
	printf("\n\t%lli\n\n",circulars_number-1);

	return 0;
}
int numerical_permutations(long long int NUMBER_OF_ARGUMENTS,...)
{
	if(NUMBER_OF_ARGUMENTS>1)
	{
		int digits_of_the[]={0,0,0,0,0,0,0,0,0,0},index=0,length;
		char first_argument[20],another_argument[20];
		va_list argptr;

		va_start(argptr,NUMBER_OF_ARGUMENTS);
		sprintf(first_argument,"%lli",va_arg(argptr,long long int));
		length=strlen(first_argument);
		for(;index<length;index++)
			digits_of_the[first_argument[index]-48]++;
		while(--NUMBER_OF_ARGUMENTS>0)
		{
			int digits_of[]={0,0,0,0,0,0,0,0,0,0};

			sprintf(another_argument,"%lli",va_arg(argptr,long long int));
			if(length!=strlen(another_argument))
				return 0;
			for(index=0;index<length;index++)
				digits_of[another_argument[index]-48]++;
			for(index=0;index<10 && digits_of_the[index]==digits_of[index];index++);
			if(index<10)
			{
				va_end(argptr);
				return 0;
			}
		}
		va_end(argptr);
		return 1;
	}
	return 0;
}
int prime(long long int VALUE, long long int *PRIMES_ARRAY,...)
{
	VALUE=llabs(VALUE);
	switch(VALUE)
	{
		case 0:
		case 1:return 0;
		case 2:return 1;
		default:
		{
			if(VALUE%2!=0)
			{
				long long int divisor=1,square_root=sqrt(VALUE)+1;

				if(PRIMES_ARRAY!=NULL)
				{
					long long int index=1,primes_number;
					va_list argptr;

					va_start(argptr,PRIMES_ARRAY);
					primes_number=va_arg(argptr,long long int);
					va_end(argptr);
					for(divisor=PRIMES_ARRAY[index];divisor<square_root&&++index<primes_number;divisor=PRIMES_ARRAY[index])
						if(VALUE%divisor==0)
							return 0;
				}
				for(divisor+=2;divisor<=square_root;divisor+=2)
					if(VALUE%divisor==0)
						return 0;
				return 1;
			}
			else
				return 0;
		}
	}
}
long long int *primes_below(long long int MAX_VALUE,long long int *PRIMES_NUMBER)	// MAX_VALUE is the number below we
{											// want to generate the primes.
	long long int *primes_array=NULL;

	if(MAX_VALUE>2)
	{
		long long int test=3;							// To verify if it's prime
		primes_array=malloc(sizeof(long long int));
		primes_array[0]=2;
		*PRIMES_NUMBER=1;

		for(;test<MAX_VALUE;test+=2)
		{
			long long int divisor=2,index=0,square_root=sqrt(test)+1;

			for(;divisor<=square_root && test%divisor!=0 && ++index<*PRIMES_NUMBER;divisor=primes_array[index]);

			if(divisor>square_root || index==*PRIMES_NUMBER)
			{
				primes_array=realloc(primes_array,sizeof(long long int)*(*PRIMES_NUMBER+1));
				primes_array[*PRIMES_NUMBER]=test;
				++*PRIMES_NUMBER;
			}
		}
	}
	return primes_array;
}
void rotate(char *string)
{
	char ch;
	int index=0,length=0;

	for(;string[length]!='\0';length++);
	for(ch=string[0];++index<length;)
		string[index-1]=string[index];
	string[length-1]=ch;
}