int main() {
bi_initialize();
int k = 2;
bigint f1 = int_to_bi(1), f2 = int_to_bi(1), f3, tmp;
bigint zeros = int_to_bi(1000000000);
while (1) {
k++;
f3 = bi_add(f1, bi_copy(f2));
int mod = bi_int_mod(bi_copy(f3), 1000000000);
if (mod >= 100000000) {
if (is_pandigital(mod)) {
tmp = bi_copy(f3);
while (bi_compare(bi_copy(tmp), bi_copy(zeros)) > 0) {
tmp = bi_int_divide(tmp, 10);
}
if (is_pandigital(bi_to_int(tmp))) {
break;
}
}
}
f1 = f2;
f2 = f3;
}
bi_free(f2);
bi_free(f3);
bi_free(zeros);
printf("%d\n", k);
bi_terminate();
return 0;
}
/**
* @brief Does both division and modulo calculations.
*
* Used extensively when doing classical reduction.
* @param ctx [in] The bigint session context.
* @param u [in] A bigint which is the numerator.
* @param v [in] Either the denominator or the modulus depending on the mode.
* @param is_mod [n] Determines if this is a normal division (0) or a reduction
* (1).
* @return The result of the division/reduction.
*/
bigint * ICACHE_FLASH_ATTR bi_divide(BI_CTX *ctx, bigint *u, bigint *v, int is_mod)
{
int n = v->size, m = u->size-n;
int j = 0, orig_u_size = u->size;
uint8_t mod_offset = ctx->mod_offset;
comp d;
bigint *quotient, *tmp_u;
comp q_dash;
check(u);
check(v);
/* if doing reduction and we are < mod, then return mod */
if (is_mod && bi_compare(v, u) > 0)
{
bi_free(ctx, v);
return u;
}
quotient = alloc(ctx, m+1);
tmp_u = alloc(ctx, n+1);
v = trim(v); /* make sure we have no leading 0's */
d = (comp)((long_comp)COMP_RADIX/(V1+1));
/* clear things to start with */
memset(quotient->comps, 0, ((quotient->size)*COMP_BYTE_SIZE));
/* normalise */
if (d > 1)
{
u = bi_int_multiply(ctx, u, d);
if (is_mod)
{
v = ctx->bi_normalised_mod[mod_offset];
}
else
{
v = bi_int_multiply(ctx, v, d);
}
}
if (orig_u_size == u->size) /* new digit position u0 */
{
more_comps(u, orig_u_size + 1);
}
do
{
/* get a temporary short version of u */
memcpy(tmp_u->comps, &u->comps[u->size-n-1-j], (n+1)*COMP_BYTE_SIZE);
/* calculate q' */
if (U(0) == V1)
{
q_dash = COMP_RADIX-1;
}
else
{
q_dash = (comp)(((long_comp)U(0)*COMP_RADIX + U(1))/V1);
if (v->size > 1 && V2)
{
/* we are implementing the following:
if (V2*q_dash > (((U(0)*COMP_RADIX + U(1) -
q_dash*V1)*COMP_RADIX) + U(2))) ... */
comp inner = (comp)((long_comp)COMP_RADIX*U(0) + U(1) -
(long_comp)q_dash*V1);
if ((long_comp)V2*q_dash > (long_comp)inner*COMP_RADIX + U(2))
{
q_dash--;
}
}
}
/* multiply and subtract */
if (q_dash)
{
int is_negative;
tmp_u = bi_subtract(ctx, tmp_u,
bi_int_multiply(ctx, bi_copy(v), q_dash), &is_negative);
more_comps(tmp_u, n+1);
Q(j) = q_dash;
/* add back */
if (is_negative)
{
Q(j)--;
tmp_u = bi_add(ctx, tmp_u, bi_copy(v));
/* lop off the carry */
tmp_u->size--;
v->size--;
}
}
else
{
Q(j) = 0;
}
/* copy back to u */
memcpy(&u->comps[u->size-n-1-j], tmp_u->comps, (n+1)*COMP_BYTE_SIZE);
} while (++j <= m);
bi_free(ctx, tmp_u);
bi_free(ctx, v);
if (is_mod) /* get the remainder */
{
bi_free(ctx, quotient);
return bi_int_divide(ctx, trim(u), d);
}
else /* get the quotient */
{
bi_free(ctx, u);
return trim(quotient);
}
}
