char *senha_pos(char *i_pass, unsigned long int interv){
int j=0,k=0;
int pass[tP];
int pos;
int aux2;
int aux;
char *c_pass;
unsigned long int dtDiv = 0, salt_aux;
c_pass = (char*)malloc((tP+1)*sizeof(char));
if(c_pass==NULL) exit(0);
memcpy(c_pass,i_pass,sizeof(char)*(tP+1));
for(j=0;j<tP;j++){
for(k=0;k<T_D;k++){
if(c_pass[j]==d[k]){
pass[j] = k;
break;
}
}
}
while(interv > T_D){
aux = 1;
pos = tP-1;
dtDiv = interv/T_D;
while(aux<=tP){
if(dtDiv > lpow(T_D,aux)){
pos--;
aux++;
}
else break;
}
pass[pos-1]++;
interv-=lpow(T_D,aux);
}
pass[tP-1] += interv-1;
for(j=tP-1;j>0;j--){
if(pass[j] > (T_D-1)){
pass[j]-=T_D;
pass[j-1]++;
}
}
for(j=0;j<tP;j++)c_pass[j] = d[pass[j]];
return c_pass;
}
main(long argc, char *argv[])
{
mpz_t n, buffer1, buffer2;
mpz_init(n); mpz_init(buffer1); mpz_init(buffer2);
if(argc == 2)
mpz_set_str(n, argv[1], 10);
if(argc == 3)
mpz_ui_pow_ui(n, atol(argv[1]), atol(argv[2]));
if (argc<2 || argc>3)
{
printf("Incorrect input format\n");
exit(1);
}
printf("Using GMP...\n");
uint64_t crn = lpow(n, 1, 3);
size_t psize = (1.26*crn)/log(crn)*sizeof(uint64_t) + 1; //add 1 because primes array will run from 1 to pi(crN) with primes[0] not used
uint64_t* primes = malloc(psize);
assert(primes!=NULL);
uint64_t i,j;
uint64_t J = sieve(crn ,primes);
int8_t* mu = malloc(sizeof(int8_t) * (crn+1)); //mu will run from 1 to crN with s[0] not used
assert(mu != NULL);
memset(mu, 1, sizeof(int8_t) * (crn+1));
uint64_t* lpf = malloc(sizeof(int64_t) * (crn+1)); //lpf will run from 1 to crN with s[0] not used
assert(lpf != NULL);
memset(lpf, 0, sizeof(int64_t) * (crn+1));
for(i=1; i<=J; i++)
for(j=primes[i]; j<=crn; j+=primes[i])
{
mu[j] = -mu[j];
if(lpf[j] == 0) lpf[j] = primes[i];
}
for(i=1; i<=J; i++)
for(j=sqr(primes[i]); j<=crn; j+=sqr(primes[i])) mu[j]=0; //remove numbers that are not squarefree
mpz_t S1_result;
mpz_init(S1_result);
printf("Calculating S1..."); fflush(stdout);
S1(n, crn, mu, S1_result);
printf("\nS1 = ");
mpz_out_str (stdout, 10, S1_result);
printf("\n\n");
free(primes); free(mu); free(lpf);
}
PassSlice *initSlices(int nprocs,char *begin){
char *beg;
PassSlice *result;
long unsigned int qtTGen = lpow(T_D,tP);
unsigned long int interv = qtTGen/nprocs;
unsigned long int intervL= qtTGen - ((nprocs-1)*interv);
int i;
result = sliceAlloc(nprocs);
beg = (char*)malloc((tP+1)*sizeof(char));
if(beg==NULL)exit(0);
beg[tP]='\0';
memcpy(beg,beegin,sizeof(char)*(tP+1));
result[0].interval = interv;
result[0].tPass = tP;
result[0].begin = beg;
result[0].end = senha_pos(result[0].begin,result[0].interval);
for(i=1;i<nprocs-1;i++){
result[i].interval = interv;
result[i].tPass = tP;
result[i].begin = (char*)malloc((result[i].tPass+1)*sizeof(char));
if(result[i].begin==NULL)exit(0);
memcpy(result[i].begin, senha_pos(result[i-1].end,2), sizeof(char)*(result[i].tPass+1));
result[i].end = senha_pos(result[i].begin,result[i].interval);
}
result[i].interval = intervL;
result[i].tPass = tP;
result[i].begin = (char*)malloc((result[i].tPass+1)*sizeof(char));
if(result[i].begin==NULL)exit(0);
memcpy(result[i].begin, senha_pos(result[i-1].end,2), sizeof(char)*(result[i].tPass+1));
result[i].end = senha_pos(result[i].begin,result[i].interval);
return result;
}
int main(long argc, char *argv[])
{
if(argc != 4)
{
printf("three arguments required\n");
exit(1);
}
mpz_t n, buffer1, buffer2;
mpz_init(n); mpz_init(buffer1); mpz_init(buffer2);
mpz_ui_pow_ui(n, atol(argv[2]), atol(argv[3]));
mpz_mul_ui(n, n, atol(argv[1]));
uint64_t crn = lpow(n, 1, 3);
uint64_t srn = lpow(n, 1, 2);
uint64_t ttrn = lpow(n, 2, 3);
uint64_t start_block = 1;
uint64_t finish_block = ttrn/crn;
size_t psize = (size_t)(((1.26*crn)/log(crn) + 1) * sizeof(uint64_t));
uint64_t* primes = (uint64_t*)malloc(psize);
assert(primes!=NULL);
uint64_t pi_crn = sieve(crn, primes);
int8_t* mu = malloc(sizeof(int8_t) * (crn+1)); //mu will run from 1 to crn with s[0] not used
assert(mu != NULL);
memset(mu, 1, sizeof(int8_t) * (crn+1));
uint64_t* lpf = malloc(sizeof(uint64_t) * (crn+1)); //lpf will run from 1 to crn with s[0] not used
assert(lpf != NULL);
memset(lpf, 0, sizeof(uint64_t) * (crn+1));
uint64_t i, j;
for(i=1; i<=pi_crn; i++)
for(j=primes[i]; j<=crn; j+=primes[i])
{
mu[j] = -mu[j];
if(lpf[j] == 0) lpf[j] = primes[i];
}
for(i=1; i<=pi_crn; i++)
for(j=sqr(primes[i]); j<=crn; j+=sqr(primes[i])) mu[j]=0; //remove numbers that are not squarefree
uint64_t blocksize = crn;
uint64_t num_blocks = ttrn/blocksize;
assert(start_block <= finish_block);
assert(finish_block <= num_blocks);
mpz_t S2_result;
mpz_init(S2_result);
uint64_t* s = malloc((crn/64+2)*sizeof(uint64_t));
assert(s != NULL);
uint64_t* phi = malloc((pi_crn+1)*sizeof(uint64_t));
memset(phi, 0, (pi_crn+1)*sizeof(uint64_t));
uint64_t p, f, m, k, start, q, block_id, first_m, last_m, L, U, first_f;
for(block_id = start_block; block_id <= finish_block; block_id++)
{
memset(s, ~0, sizeof(uint64_t) * (crn/64+2));
L = (block_id -1)*blocksize + 1;
U = L + blocksize;
for(i=1; i<=pi_crn; i++)
{
p = primes[i];
mpz_fdiv_q_ui(buffer1, n, L*p);
mpz_fdiv_q_ui(buffer2, n, U*p);
first_m = mpz_get_ui(buffer1);
last_m = mpz_get_ui(buffer2);
if(first_m > crn) first_m = crn;
if(last_m > first_m) last_m = first_m;
if(p > first_m) break;
start = L;
for(m = first_m; m > last_m && p*m > crn ; m--)
{
if(mu[m] != 0 && p < lpf[m] && p*m > crn && m <= crn)
{
mpz_fdiv_q_ui(buffer1, n, p*m);
q = mpz_get_ui(buffer1);
assert(q>=L);
assert(q<=U);
phi[i] += count_bits(s, start - L, q - L);
start = q+1;
if(mu[m] > 0) mpz_sub_ui(S2_result, S2_result, mu[m] * phi[i]);
else mpz_add_ui(S2_result, S2_result, -mu[m] * phi[i]);
}
}
phi[i] += count_bits(s, start - L, U -1 - L);
sieve_step(start, U, phi,s, L, p);
}
}
uint64_t short_block_length = ttrn % blocksize;
if(short_block_length>0)
{
//short block
L = L + blocksize;
U = L + short_block_length;
memset(s, ~0, sizeof(uint64_t) * (crn/64+2));
for(i=1; i<=pi_crn; i++)
{
start = L;
p = primes[i];
mpz_fdiv_q_ui(buffer1, n, L*p);
mpz_fdiv_q_ui(buffer2, n, U*p);
first_m = mpz_get_ui(buffer1);
last_m = mpz_get_ui(buffer2);
if(first_m > crn) first_m = crn;
if(last_m > first_m) last_m = first_m;
if(p > first_m) break;
for(m=first_m; m>last_m && p*m>crn ; m--)
{
if(mu[m]!=0 && p<lpf[m] && p*m>crn && m<=crn)
{
mpz_fdiv_q_ui(buffer1, n, p*m);
q = mpz_get_ui(buffer1);
assert(q>=L);
assert(q<=U);
phi[i] += count_bits(s, start - L, q - L);
start = q+1;
if(mu[m] > 0) mpz_sub_ui(S2_result, S2_result, mu[m]*phi[i]);
else mpz_add_ui(S2_result, S2_result, -mu[m]*phi[i]);
}
}
sieve_step(start, U, phi,s, L, p);
}
}
mpz_out_str (stdout, 10, S2_result);
printf("\n");
mpz_clears(buffer1, buffer2, n, S2_result, NULL);
free(s); free(phi);
free(primes); free(mu);
free(lpf);
return(0);
}
