Var
compare_numbers(Var a, Var b)
{
Var ans;
if (a.type != b.type) {
ans.type = TYPE_ERR;
ans.v.err = E_TYPE;
} else if (a.type == TYPE_INT) {
ans.type = TYPE_INT;
ans.v.num = compare_integers(a.v.num, b.v.num);
} else {
double aa = *a.v.fnum, bb = *b.v.fnum;
ans.type = TYPE_INT;
if (aa < bb)
ans.v.num = -1;
else if (aa == bb)
ans.v.num = 0;
else
ans.v.num = 1;
}
return ans;
}
void mod_integer(integer left, integer right, integer result) {
integer mod_two_power = create_integer(right.num_components + 1);
int i, bit;
set_zero_integer(result);
set_zero_integer(mod_two_power);
mod_two_power.c[0] = 1;
for(i=0; i<left.num_components; i++) {
for(bit=0; bit<COMPONENT_BITS; bit++) {
if ((left.c[i] & (1 << bit)) != 0) {
add_integer(result, mod_two_power, result);
if (compare_integers(result, right) >= 0) {
subtract_integer(result, right, result);
}
}
shift_left_one_integer(mod_two_power);
if (compare_integers(mod_two_power, right) >= 0) {
subtract_integer(mod_two_power, right, mod_two_power);
}
}
}
free_integer(mod_two_power);
}
unsigned int integer_to_binary(unsigned char** result,integer data,int keyLenBytes){
integer base=string_to_integer("256");
integer div=create_integer(data.num_components);
copy_integer(data,div);
integer zero=create_integer(1);
zero.c[0]=0;
unsigned char* pf=new unsigned char[data.num_components];
for(int i=0; i<data.num_components; i++){
pf[i]=0;
}
int tpos=data.num_components-1;
pf[tpos]=div.c[0];
tpos--;
while(compare_integers(div,zero)==1){
integer mod=create_integer(div.num_components+1+1);
mod_integer(div,base,mod);
integer div_temp=create_integer(div.num_components);
copy_integer(div,div_temp);
divide_small_integer(div_temp,256,div);
pf[tpos]=div.c[0];
tpos--;
}
int startpos=div.num_components-keyLenBytes;
*result=new unsigned char[keyLenBytes];
for(int i=0; i<keyLenBytes; i++){
(*result)[i]=pf[i+startpos];
}
return keyLenBytes;
}
int problem263()
{
integer testnum = string_to_integer("5");
integer testnum_helper = string_to_integer("5");
integer two = string_to_integer("2");
integer total_src = string_to_integer("0");
integer total_tar = string_to_integer("0");
integer target_dif = string_to_integer("6");
integer dif = string_to_integer("0");
int found = 0;
integer lastprime = string_to_integer("5");
//int sexy_count = 0;
printf("text here\n");
while (found < 4) {
//printf("gets 1\n");
if (miller_rabin(testnum) == PRIME) {
subtract_integer(testnum, lastprime, dif);
if (compare_integers(dif, target_dif) == 0) {
printf("difference between %s and %s is six\n",
integer_to_string(testnum), integer_to_string(lastprime));
found++;
}else {
found = 1;
}
copy_integer(testnum, lastprime);
add_integer(total_src, testnum, total_tar);
copy_integer(total_tar, total_src);
printf("Total is %s\n", integer_to_string(total_tar));
}
add_integer(testnum_helper, two, testnum);
copy_integer(testnum, testnum_helper);
printf("Tested %s\n", integer_to_string(testnum));
}
return 0;
}
int pow_mod(unsigned char** result,unsigned char* p,unsigned char* q, unsigned char* r,unsigned int keyLengthBytes){
std::set_new_handler(newh);
Array<integer> factors;
integer div=hex_to_integer(q,keyLengthBytes,0);
int siz=keyLengthBytes;
integer power_of_two=create_integer(siz);
set_zero_integer(power_of_two);
integer zero=create_integer(1);
set_zero_integer(zero);
integer two=string_to_integer("2");
integer one=string_to_integer("1");
int i=0;
integer div_temp=create_integer(div.num_components);
integer rem=create_integer(div.num_components+2);
while(compare_integers(div, zero) == 1){
set_zero_integer(rem);
mod_integer(div, two,rem);
copy_integer(div,div_temp);
divide_small_integer(div_temp,2,div);
if(compare_integers(rem, zero) == 1){
integer ptt=create_integer(power_of_two.num_components);
copy_integer(power_of_two,ptt);
factors.pushBack(ptt);
}
add_integer(power_of_two,one,power_of_two);
i++;
}
free_integer(rem);
free_integer(div_temp);
Array<integer> partial_results;
integer part_res=hex_to_integer(p,keyLengthBytes,2);
integer ri=hex_to_integer(r,keyLengthBytes,1);
integer idx = create_integer(part_res.num_components);
set_zero_integer(idx);
integer part_res_temp1=create_integer(part_res.num_components);
integer part_res_temp2=create_integer(part_res.num_components);
integer part_res_temp3=create_integer(part_res.num_components);
for(int i=0; i<factors.size(); i++){
while(compare_integers(factors[i],idx)==1){
copy_integer(part_res,part_res_temp1);
copy_integer(part_res,part_res_temp2);
multiply_integer(part_res_temp1,part_res_temp2,part_res);
copy_integer(part_res,part_res_temp3);
mod_integer(part_res_temp3,ri,part_res);
add_integer(idx,one,idx);
}
integer ptt=create_integer(part_res.num_components);
copy_integer(part_res,ptt);
partial_results.pushBack(ptt);
}
free_integer(part_res_temp1);
free_integer(part_res_temp2);
free_integer(part_res_temp3);
integer resulti=create_integer(ri.num_components+1);
set_zero_integer(resulti);
resulti.c[0]=1;
integer resulti_temp=create_integer(resulti.num_components);
integer resulti_temp2=create_integer(resulti.num_components);
for(int i=0; i<partial_results.size(); i++){
copy_integer(resulti,resulti_temp);
multiply_integer(resulti_temp,partial_results[i],resulti);
copy_integer(resulti,resulti_temp2);
mod_integer(resulti_temp2,ri,resulti);
}
free_integer(resulti_temp);
free_integer(resulti_temp2);
int lol=integer_to_binary(result,resulti,keyLengthBytes);
return lol;
}
