int main(int argc, char** argv) {
int plen, diff, k, i_l, j_l, k_l;
int* i_s;
int* j_s;
int* k_s;
int* primes = find_primes(10000, &plen);
for (int i = 0; i < plen; ++i) {
for (int j = i + 1; j < (plen-1); ++j) {
if (primes[i] < 1000 || primes[j] < 1000 ||
primes[i] == 1487)
continue;
// primes[j] > primes[i]
diff = primes[j] - primes[i];
k = primes[j] + diff;
if (k < 10000 && is_prime(primes, plen, k)) {
i_s = split_number(primes[i], &i_l);
j_s = split_number(primes[j], &j_l);
if (are_perms49(i_s, j_s)) {
k_s = split_number(k, &k_l);
if (are_perms49(j_s, k_s)) {
printf("%d %d %d\n", primes[i], primes[j], k);
free(k_s);
free(j_s);
free(i_s);
return 0;
}
free(k_s);
}
free(j_s);
free(i_s);
}
}
}
return 0;
}
vector<long long> BigNum::kmul(vector<long long>& numbers, IPos begin, IPos end, vector<long long>& o_numbers, IPos o_begin, IPos o_end, long long base)
{
if ( (end - begin) <= 1 && (o_end - o_begin) <= 1 )
{
vector<long long> res_numbers;
long long m1 = (end - begin) == 1 ? (*begin) : 0;
long long m2 = (o_end - o_begin) == 1 ? (*o_begin) : 0;
res_numbers.push_back(m1 * m2);
long long div = res_numbers[0] / base;
long i = 0;
while ( div != 0 )
{
res_numbers[i] %= base;
res_numbers.push_back(div);
++i;
div = res_numbers[i] / base;
}
return res_numbers;
}
long size = max(end - begin, o_end - o_begin);
long count = size / 2;
if ( size % 2 == 1 )
count++;
IPos middle, o_middle;
split_number(begin, end, numbers, &middle, count);
split_number(o_begin, o_end, o_numbers, &o_middle, count);
vector<long long> u1mv1 = kmul(numbers, middle, end, o_numbers, o_middle, o_end, base);
vector<long long> u0mv0 = kmul(numbers, begin, middle, o_numbers, o_begin, o_middle, base);
vector<long long> u1au0 = add(numbers, middle, end, numbers, begin, middle, base);
trim_num_zeroes(u1au0);
vector<long long> v1av0 = add(o_numbers, o_middle, o_end, o_numbers, o_begin, o_middle, base);
trim_num_zeroes(v1av0);
vector<long long> umv = full_kmul(u1au0, v1av0, base);
vector<long long> sum2 = full_sub(umv, u0mv0, base);
sum2 = full_sub(sum2, u1mv1, base);
lshift(&u1mv1, count * 2);
lshift(&sum2, count);
vector<long long> res = full_add(u1mv1, sum2, base);
res = full_add(res, u0mv0, base);
trim_num_zeroes(res);
return res;
}
void Test_join_shares(CuTest* tc) {
int n = 200;
int t = 100;
int shares[n*2];
int count = 255; /* How many times should we test it? */
int j;
for (j = 0; j < count; ++j)
{
int * test = split_number(j, n, t);
int i;
for (i = 0; i < n; ++i)
{
shares[i*2] = i + 1;
shares[i*2 + 1] = test[i];
}
/* Send all n shares */
int result = join_shares(shares, n);
free(test);
CuAssertIntEquals(tc, j, result);
}
}
void Test_split_number(CuTest* tc) {
seed_random();
int * test = split_number(1234, 50, 20);
free(test);
CuAssertIntEquals(tc, 0, 0);
}
static u_int
count_digits(const struct number *n)
{
struct number *int_part, *fract_part;
u_int i;
if (BN_is_zero(n->number))
return n->scale ? n->scale : 1;
int_part = new_number();
fract_part = new_number();
fract_part->scale = n->scale;
split_number(n, int_part->number, fract_part->number);
i = 0;
while (!BN_is_zero(int_part->number)) {
BN_div_word(int_part->number, 10);
i++;
}
free_number(int_part);
free_number(fract_part);
return (i + n->scale);
}
void
printnumber(FILE *f, const struct number *b, u_int base)
{
struct number *int_part, *fract_part;
int digits;
char buf[11];
size_t sz;
int i;
struct stack stack;
char *p;
charcount = 0;
lastchar = -1;
if (BN_is_zero(b->number))
putcharwrap(f, '0');
int_part = new_number();
fract_part = new_number();
fract_part->scale = b->scale;
if (base <= 16)
digits = 1;
else {
digits = snprintf(buf, sizeof(buf), "%u", base-1);
}
split_number(b, int_part->number, fract_part->number);
i = 0;
stack_init(&stack);
while (!BN_is_zero(int_part->number)) {
BN_ULONG rem = BN_div_word(int_part->number, base);
stack_pushstring(&stack, get_digit(rem, digits, base));
i++;
}
sz = i;
if (BN_cmp(b->number, &zero) < 0)
putcharwrap(f, '-');
for (i = 0; i < sz; i++) {
p = stack_popstring(&stack);
if (base > 16)
putcharwrap(f, ' ');
printwrap(f, p);
free(p);
}
stack_clear(&stack);
if (b->scale > 0) {
struct number *num_base;
BIGNUM mult, stop;
putcharwrap(f, '.');
num_base = new_number();
BN_set_word(num_base->number, base);
BN_init(&mult);
BN_one(&mult);
BN_init(&stop);
BN_one(&stop);
scale_number(&stop, b->scale);
i = 0;
while (BN_cmp(&mult, &stop) < 0) {
u_long rem;
if (i && base > 16)
putcharwrap(f, ' ');
i = 1;
bmul_number(fract_part, fract_part, num_base);
split_number(fract_part, int_part->number, NULL);
rem = BN_get_word(int_part->number);
p = get_digit(rem, digits, base);
int_part->scale = 0;
normalize(int_part, fract_part->scale);
BN_sub(fract_part->number, fract_part->number,
int_part->number);
printwrap(f, p);
free(p);
BN_mul_word(&mult, base);
}
free_number(num_base);
BN_free(&mult);
BN_free(&stop);
}
flushwrap(f);
free_number(int_part);
free_number(fract_part);
}
static void
bexp(void)
{
struct number *a, *p;
struct number *r;
bool neg;
u_int rscale;
p = pop_number();
if (p == NULL)
return;
a = pop_number();
if (a == NULL) {
push_number(p);
return;
}
if (p->scale != 0) {
BIGNUM *i, *f;
i = BN_new();
bn_checkp(i);
f = BN_new();
bn_checkp(f);
split_number(p, i, f);
if (!BN_is_zero(f))
warnx("Runtime warning: non-zero fractional part in exponent");
BN_free(i);
BN_free(f);
}
normalize(p, 0);
neg = false;
if (BN_is_negative(p->number)) {
neg = true;
negate(p);
rscale = bmachine.scale;
} else {
/* Posix bc says min(a.scale * b, max(a.scale, scale) */
u_long b;
u_int m;
b = BN_get_word(p->number);
m = max(a->scale, bmachine.scale);
rscale = a->scale * (u_int)b;
if (rscale > m || (a->scale > 0 && (b == ULONG_MAX ||
b > UINT_MAX)))
rscale = m;
}
if (BN_is_zero(p->number)) {
r = new_number();
bn_check(BN_one(r->number));
normalize(r, rscale);
} else {
u_int ascale, mscale;
ascale = a->scale;
while (!BN_is_bit_set(p->number, 0)) {
ascale *= 2;
bmul_number(a, a, a, ascale);
bn_check(BN_rshift1(p->number, p->number));
}
r = dup_number(a);
bn_check(BN_rshift1(p->number, p->number));
mscale = ascale;
while (!BN_is_zero(p->number)) {
ascale *= 2;
bmul_number(a, a, a, ascale);
if (BN_is_bit_set(p->number, 0)) {
mscale += ascale;
bmul_number(r, r, a, mscale);
}
bn_check(BN_rshift1(p->number, p->number));
}
if (neg) {
BN_CTX *ctx;
BIGNUM *one;
one = BN_new();
bn_checkp(one);
bn_check(BN_one(one));
ctx = BN_CTX_new();
bn_checkp(ctx);
scale_number(one, r->scale + rscale);
if (BN_is_zero(r->number))
warnx("divide by zero");
else
bn_check(BN_div(r->number, NULL, one,
r->number, ctx));
BN_free(one);
BN_CTX_free(ctx);
r->scale = rscale;
} else
normalize(r, rscale);
}
push_number(r);
free_number(a);
free_number(p);
}
