int main(int argc, const char *argv[])
{
elliptic_context ctx;
elliptic_point point;
if(argc != 6)
return 1;
elliptic_curve_init(&ctx);
mpz_set_str(ctx.A, argv[1], 0);
mpz_set_str(ctx.B, argv[2], 0);
mpz_set_str(ctx.m, argv[3], 0);
ctx.type = ELLIPTIC_CURVE_MONTGOMERY;
mpz_init_set_str(point.x, argv[4], 0);
mpz_init_set_str(point.y, argv[5], 0);
mpz_init(point.z);
point.type = POINT_AFFINE;
elliptic_curve_double(&point, &point, &ctx);
gmp_printf("%Zd\t%Zd\n", point.x, point.y);
return 0;
}
int main (int argc, char **argv)
{
mpz_t a, b, p;
if (argc != 3)
{
printf ("Usage: %s <number> <number>\n", argv[0]);
return 1;
}
/* Initialize and assign a and b from base 10 strings in argv */
mpz_init_set_str (a, argv[1], 10);
mpz_init_set_str (b, argv[2], 10);
/* Initialize p */
mpz_init (p);
/* Multiply a and b and put the result in p */
mpz_mul (p, a, b);
/* Print p in decimal */
gmp_printf ("Product is: %Zd\n", p);
/* Since we're about to exit, no need to clear out variables */
return 0;
}
/******************************************************************************
PYTHON BINDINGS
******************************************************************************/
static PyObject * _ecdsa_sign(PyObject *self, PyObject *args) {
char * msg, * d, * k, * p, * a, * b, * q, * gx, * gy;
if (!PyArg_ParseTuple(args, "sssssssss", &msg, &d, &k, &p, &a, &b, &q, &gx, &gy)) {
return NULL;
}
mpz_t privKey, nonce;
CurveZZ_p * curve = buildCurveZZ_p(p, a, b, q, gx, gy, 10);
Sig sig;
mpz_init_set_str(privKey, d, 10);
mpz_init_set_str(nonce, k, 10);
signZZ_p(&sig, msg, privKey, nonce, curve);
destroyCurveZZ_p(curve);
char * resultR = mpz_get_str(NULL, 10, sig.r);
char * resultS = mpz_get_str(NULL, 10, sig.s);
mpz_clears(sig.r, sig.s, privKey, NULL);
PyObject * ret = Py_BuildValue("ss", resultR, resultS);
free(resultR);
free(resultS);
return ret;
}
/*
* It is a function that performs Extended Euclid
* input: mpz_t of a, b, s and t
* output: variable a as the GCD and give s and t values
*/
void extendedEuclid(mpz_t a, mpz_t b, mpz_t s, mpz_t t){
mpz_t q, r, r1, r2,s1,s2,t1,t2, temp;
mpz_init(q);
mpz_init(r1);
mpz_init(r2);
mpz_init(temp);
mpz_set(r1, a);
mpz_set(r2, b);
mpz_init_set_str(r, "1", 10); //to prevent r from inheriting other value
mpz_init_set_str(s1, "1", 10);
mpz_init_set_str(s2, "0", 10);
mpz_init_set_str(t1, "0", 10);
mpz_init_set_str(t2, "1", 10);
while(mpz_cmp_ui(r2,0) != 0){
mpz_cdiv_q(q, r1, r2);
mpz_cdiv_r(r, r1, r2);
mpz_mul(temp, q, s2);
mpz_sub(s, s1, temp);
mpz_mul(temp, q, t2);
mpz_sub(t, t1, temp);
mpz_set(r1, r2);
mpz_set(r2, r);
mpz_set(s1, s2);
mpz_set(s2, s);
mpz_set(t1, t2);
mpz_set(t2, t);
}
mpz_set(s, s1);
mpz_set(t, t1);
mpz_set(a, r1);
}
int main(int argc, const char * argv[])
{
char *filePath = NULL;
PathInit(argv[0]);
PathForFile("w256-001.gp", &filePath);
assert(filePath != NULL);
CurveRef curve = CurveCreateFromFile(filePath);
assert(curve != NULL);
PointRef g = curve->g;
mpz_t m;
mpz_init_set_str(m, "888493310283202167031085660111238327945443791805939712000426466539273165903", 10);
PointRef g2 = PointCreateMultiple(g, m, curve);
mpz_t xr, yr;
mpz_init_set_str(xr, "5441683091496050436439782524673611468679503009264125966279940185557193452058", 10);
mpz_init_set_str(yr, "126373273530397135676109694298926901726086297191360274402845796485476517565", 10);
assert(mpz_cmp(g2->x, xr) == 0);
assert(mpz_cmp(g2->y, yr) == 0);
mpz_set_si(m, 0);
PointRef g3 = PointCreateMultiple(g, m, curve);
assert(PointIsTeta(g3));
mpz_set_si(m, 1);
PointRef g4 = PointCreateMultiple(g, m, curve);
assert(PointEqual(g4, g));
return 0;
}
void ecc_init_curve(ecc_curve *c, char *p, char *a, int max_bits, int max_str)
{
c->max_bits = max_bits;
c->max_str = max_str;
mpz_init_set_str(c->p, p, 10);
mpz_init_set_str(c->a, a, 10);
}
int main(int argc, char** argv) {
if(argc < 3) {
fprintf(stderr, "usage: %s <n> <k>\n", argv[0]);
return 1;
}
#if USE_GMP == 0
unsigned long long n = atoll(argv[1]);
unsigned long long k = atoll(argv[2]);
printf("calculating nchoosek(%li, %li) (native)... \n", n, k);
printf("result: %li\n", nchoosek_native(n, k));
#else
mpz_t n;
mpz_t k;
mpz_t result;
mpz_init(result);
mpz_init_set_str(n, argv[1], 10);
mpz_init_set_str(k, argv[2], 10);
gmp_printf("calculating nchoosek(%Zd, %Zd) (GMP)... \n", n, k);
nchoosek_gmp(result, n, k);
gmp_printf("result: %Zd\n", result);
mpz_clear(n);
mpz_clear(k);
mpz_clear(result);
#endif
return 0;
}
int main(int argc, char *argv[])
{
mpz_t a, b, c, p, r;
//init mpz_t
mpz_init2(a, 576);
mpz_init2(b, 576);
mpz_init2(c, 1280);
mpz_init2(p, 576);
mpz_init2(r, 576);
//input
mpz_init_set_str(a, Gx, 16);
mpz_init_set_str(b, Gy, 16);
mpz_init_set_str(p, P521, 16);
//process
mpz_mul(c, a, b);//c = a *b
mpz_mod(r, c, p);//r = c mod p
//output
mpz_out_str(stdout, 16, c);
fprintf(stdout, "\r\n");
mpz_out_str(stdout, 16, r);
fprintf(stdout, "\r\n");
//free
mpz_clear(a);
mpz_clear(b);
mpz_clear(c);
mpz_clear(p);
exit(EXIT_SUCCESS);
}
// **TODO**: Add an test. This function shows only the usage of `append_cb`.
static char * test_single() {
mpz_t a, b;
mpz_array array1, array2, array_expect;
mpz_pool pool;
pool_init(&pool, 0);
array_init(&array1, 3);
array_init(&array2, 3);
array_init(&array_expect, 3);
// primes: 577, 727, 863
mpz_init_set_str(a, "577", 10);
array_add(&array_expect, a);
mpz_set_str(a, "727", 10);
array_add(&array_expect, a);
mpz_set_str(a, "863", 10);
array_add(&array_expect, a);
// `a = 727 * 577 = 419479`
// `b = 727 * 863 = 627401`
mpz_set_str(a, "419479", 10);
mpz_init_set_str(b, "627401", 10);
append_cb(&pool, &array1, a, b);
if (mpz_cmp_ui(a, 419479) != 0) {
return "append_cb has changed the input value a!";
}
if (mpz_cmp_ui(b, 627401) != 0) {
return "append_cb has changed the input value b!";
}
array_msort(&array1);
if (!array_equal(&array_expect, &array1)) {
return "array1 and array_expect differ!";
}
append_cb(&pool, &array2, b, a);
if (mpz_cmp_ui(a, 419479) != 0) {
return "append_cb has changed the input value a!";
}
if (mpz_cmp_ui(b, 627401) != 0) {
return "append_cb has changed the input value b!";
}
array_msort(&array2);
if (!array_equal(&array_expect, &array2)) {
return "array2 and array_expect differ!";
}
mpz_clear(a);
mpz_clear(b);
array_clear(&array1);
array_clear(&array2);
array_clear(&array_expect);
pool_clear(&pool);
return 0;
}
// This function calculates `ppi`, `ppo` and `gcd` and compares the value to the expected strings.
static char * test_gcd_ppi_ppo(char * str_a, char * str_b, char * str_expect_gcd, char * str_expect_ppi, char * str_expect_ppo) {
mpz_t a;
mpz_t b;
mpz_t a0;
mpz_t b0;
mpz_t gcd;
mpz_t ppi;
mpz_t ppo;
mpz_t expect_gcd;
mpz_t expect_ppi;
mpz_t expect_ppo;
mpz_init_set_str(a, str_a, 10);
mpz_init_set_str(b, str_b, 10);
mpz_init_set(a0, a);
mpz_init_set(b0, b);
mpz_init(gcd);
mpz_init(ppi);
mpz_init(ppo);
mpz_init_set_str(expect_gcd, str_expect_gcd, 10);
mpz_init_set_str(expect_ppi, str_expect_ppi, 10);
mpz_init_set_str(expect_ppo, str_expect_ppo, 10);
gcd_ppi_ppo(gcd, ppi, ppo, a, b);
// Check the return values.
if (mpz_cmp(expect_gcd, gcd) != 0) {
return "gcd calculation error";
}
if (mpz_cmp(expect_ppi, ppi) != 0) {
return "ppi calculation error";
}
if (mpz_cmp(expect_ppo, ppo) != 0) {
return "ppo calculation error";
}
if (mpz_cmp(a, a0) != 0) {
return "input value a has changed";
}
if (mpz_cmp(b, b0) != 0) {
return "input value b has changed";
}
mpz_clear(a);
mpz_clear(b);
mpz_clear(a0);
mpz_clear(b0);
mpz_clear(gcd);
mpz_clear(ppi);
mpz_clear(ppo);
mpz_clear(expect_gcd);
mpz_clear(expect_ppi);
mpz_clear(expect_ppo);
return 0;
}
CurveZZ_p * buildCurveZZ_p(char * p, char * a, char * b, char * q, char * gx, char * gy, int base) {
CurveZZ_p * curve = (CurveZZ_p *)malloc(sizeof(CurveZZ_p));
mpz_init_set_str(curve->p, p, base);
mpz_init_set_str(curve->a, a, base);
mpz_init_set_str(curve->b, b, base);
mpz_init_set_str(curve->q, q, base);
curve->g = buildPointZZ_p(gx, gy, base);
return curve;
}
extern "C" PyObject* PyLong_FromString(const char* str, char** pend, int base) noexcept {
RELEASE_ASSERT(pend == NULL, "unsupported");
int sign = 1;
if ((base != 0 && base < 2) || base > 36) {
PyErr_SetString(PyExc_ValueError, "long() arg 2 must be >= 2 and <= 36");
return NULL;
}
while (*str != '\0' && isspace(Py_CHARMASK(*str)))
str++;
if (*str == '+')
++str;
else if (*str == '-') {
++str;
sign = -1;
}
while (*str != '\0' && isspace(Py_CHARMASK(*str)))
str++;
if (base == 0) {
/* No base given. Deduce the base from the contents
of the string */
if (str[0] != '0')
base = 10;
else if (str[1] == 'x' || str[1] == 'X')
base = 16;
else if (str[1] == 'o' || str[1] == 'O')
base = 8;
else if (str[1] == 'b' || str[1] == 'B')
base = 2;
else
/* "old" (C-style) octal literal, still valid in
2.x, although illegal in 3.x */
base = 8;
}
/* Whether or not we were deducing the base, skip leading chars
as needed */
if (str[0] == '0'
&& ((base == 16 && (str[1] == 'x' || str[1] == 'X')) || (base == 8 && (str[1] == 'o' || str[1] == 'O'))
|| (base == 2 && (str[1] == 'b' || str[1] == 'B'))))
str += 2;
BoxedLong* rtn = new BoxedLong();
if (str[strlen(str) - 1] == 'L') {
std::string without_l(str, strlen(str) - 1);
int r = mpz_init_set_str(rtn->n, without_l.c_str(), base);
RELEASE_ASSERT(r == 0, "");
} else {
int r = mpz_init_set_str(rtn->n, str, base);
RELEASE_ASSERT(r == 0, "");
}
if (sign == -1)
mpz_neg(rtn->n, rtn->n);
return rtn;
}
void init() {
mpz_init(g_r_1);
mpz_init(g_s_1);
mpz_init_set_str(_mpz_3, "3", 10);
mpz_init_set_str(_mpz_4, "4", 10);
mpz_init_set_str(_mpz_11, "11", 10);
mpz_init_set_str(_mpz_23, "23", 10);
gmp_randinit_default(rstate);
}
int main() {
big a,b,c;
mpz_init_set_str(a,"123456789123456789123",10);
mpz_init_set_str(b,"98123981239457",10);
mpz_init(c);
mpz_mul(c,a,b);
printf("%s * %s = %s\n",mpz_get_str(NULL,10,a),mpz_get_str(NULL,10,b),mpz_get_str(NULL,10,c));
mpz_clear(a);
mpz_clear(b);
mpz_clear(c);
return 0;
}
int init_curve(char* a1, char* b1,char* prime1, char* order1,int cofactor1,ecc_point g1){
mpz_init_set_str(a,a1,BASE_16);
mpz_init_set_str(b,b1,BASE_16);
mpz_init_set_str(prime,prime1,BASE_16);
mpz_init_set_str(order,order1,BASE_16);
cofactor= cofactor1;
if ( existPoint1(g1.x,g1.y)){
generator_point=g1;
return 0;
}else
return -1;
}
int main(int argc, char *argv[]) {
mpz_t a, b; /* working numbers */
if (argc < 3) { /* not enough words */
printf("Please supply two numbers to add.\n");
return 1;
}
mpz_init_set_str(a, argv[1], 10); /* Assume decimal integers */
mpz_init_set_str(b, argv[2], 10); /* Assume decimal integers */
mpz_add(a, a, b); /* a=a+b */
printf("%s + %s => %s\n", argv[1], argv[2], mpz_get_str(NULL, 10, a));
return 0;
}
mpz_t* fnv_hash_mpz(const void *key, int keylen,int keysize){
mpz_t *hash,*fnv_prime,*cur_octet;
mpz_init_set_str(*hash,offset_basis_512,0);
mpz_init_set_str(*fnv_prime,fnv_prime_512,0);
mpz_init(*cur_octet);
const uint8_t *raw_data=(const uint8_t *)key;
int i;
for(i=0;i<keylen;i++){
mpz_set_ui(*cur_octet,(uint64_t)raw_data[i]);
mpz_xor(*hash,*hash,*cur_octet);
mpz_mul(*hash,*hash,*fnv_prime);
}
return hash;
}
void QtGMP::powAB()
{
QString s("");
mpz_t aa,bb,cc;
char *str=0;
mpz_init(cc);
mpz_init_set_str(aa,qPrintable(this->lineEdit1->text()),10);
mpz_init_set_str(bb,qPrintable(this->lineEdit2->text()),10);
mpz_pow_ui(cc,aa,mpz_get_ui(bb));
// gmp_printf("A:\t%Zd\n\B:\t%ZdnA^B:\t%Zd\n\n\n",aa,bb,cc);
s.sprintf("A:\t%s\nB:\t%s\nA^B:\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb),mpz_get_str(str,10,cc));
this->textEdit->setText(s);
mpz_clears(aa,bb,cc,'\0');
}
void dh_params(mpz_t p, mpz_t g)
{
char p_str[] = "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024"
"e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd"
"3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec"
"6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f"
"24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361"
"c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552"
"bb9ed529077096966d670c354e4abc9804f1746c08ca237327fff"
"fffffffffffff";
mpz_init_set_str(p, p_str, 16);
mpz_init_set_str(g, "2", 10);
}
static void
test_ecdsa (const struct ecc_curve *ecc,
/* Private key */
const char *sz,
/* Random nonce */
const char *sk,
/* Hash */
const struct tstring *h,
/* Expected signature */
const char *r, const char *s)
{
struct dsa_signature ref;
mpz_t z;
mpz_t k;
mp_limb_t *rp = xalloc_limbs (ecc->size);
mp_limb_t *sp = xalloc_limbs (ecc->size);
mp_limb_t *scratch = xalloc_limbs (ecc_ecdsa_sign_itch (ecc));
dsa_signature_init (&ref);
mpz_init_set_str (z, sz, 16);
mpz_init_set_str (k, sk, 16);
ecc_ecdsa_sign (ecc, mpz_limbs_read_n (z, ecc->size),
mpz_limbs_read_n (k, ecc->size),
h->length, h->data, rp, sp, scratch);
mpz_set_str (ref.r, r, 16);
mpz_set_str (ref.s, s, 16);
if (mpz_limbs_cmp (ref.r, rp, ecc->size) != 0
|| mpz_limbs_cmp (ref.s, sp, ecc->size) != 0)
{
fprintf (stderr, "_ecdsa_sign failed, bit_size = %u\n", ecc->bit_size);
gmp_fprintf (stderr, "r = %Nx\n", rp, ecc->size);
gmp_fprintf (stderr, "s = %Nx\n", sp, ecc->size);
gmp_fprintf (stderr, "ref.r = %Zx\n", ref.r);
gmp_fprintf (stderr, "ref.s = %Zx\n", ref.s);
abort();
}
free (rp);
free (sp);
free (scratch);
dsa_signature_clear (&ref);
mpz_clear (k);
mpz_clear (z);
}
/* written as a one-off script mostly because (as of now) it doesn't seem to
* be needed by any other challenge. if that ends up not being the case,
* it'll be rewritten with properly general functions and everything. */
int main(void)
{
char *hex1 = "1c0111001f010100061a024b53535009181c";
char *hex2 = "686974207468652062756c6c277320657965";
mpz_t hexval1, hexval2, result;
mpz_init_set_str(hexval1, hex1, 16);
mpz_init_set_str(hexval2, hex2, 16);
mpz_init(result);
mpz_xor(result, hexval1, hexval2);
gmp_printf("%Zx\n", result);
}
void QtGMP::lcm()
{
//QApplication::aboutQt();
QString s("");
mpz_t aa,bb,cc;
char *str=0;
mpz_init(cc);
mpz_init_set_str(aa,qPrintable(this->lineEdit1->text()),10);
mpz_init_set_str(bb,qPrintable(this->lineEdit2->text()),10);
mpz_lcm(cc,aa,bb);
// gmp_printf("A:\t%Zd\nB:\t%Zd\nLCM(A,B):\t%Zd\n\n\n",aa,bb,cc);
s.sprintf("A:\t%s\nB:\t%s\nLCM(A,B):\t%s\n",mpz_get_str(str,10,aa),mpz_get_str(str,10,bb),mpz_get_str(str,10,cc));
this->textEdit->setText(s);
mpz_clears(aa,bb,cc,'\0');
}
int main(int argc, char *argv[])
{
mpz_t a, b;
if (argc<3)
{
printf("Please supply two numbers to add.\n");
return 1;
}
mpz_init_set_str (a, argv[1], 10);
mpz_init_set_str (b, argv[2], 10);
mpz_add (a, a, b);
printf("%s + %s => %s\n", argv[1], argv[2], mpz_get_str (NULL, 10, a));
return 0;
}
// **TODO**: Add an test. This function shows only the usage of `append_cb`.
static char * test_multiple() {
mpz_t a, b;
mpz_array array1, array2, array_expect;
mpz_pool pool;
pool_init(&pool, 0);
array_init(&array1, 3);
array_init(&array2, 3);
array_init(&array_expect, 3);
// `30997 = 139 * 223`
// `627401 = 727 * 863`
// `182909 = 317 * 577`
mpz_init_set_str(a, "30997", 10);
array_add(&array_expect, a);
mpz_set_str(a, "182909", 10);
array_add(&array_expect, a);
mpz_set_str(a, "627401", 10);
array_add(&array_expect, a);
// primes: 139, 223, 317, 577, 727, 863
// `a = 139 * 223 * 317 * 577 = 5669630273`
// `b = 317 * 577 * 727 * 863 = 114757289509`
mpz_set_str(a, "5669630273", 10);
mpz_init_set_str(b, "114757289509", 10);
append_cb(&pool, &array1, a, b);
array_msort(&array1);
if (!array_equal(&array_expect, &array1)) {
return "array1 and array_expect differ!";
}
append_cb(&pool, &array2, b, a);
array_msort(&array2);
if (!array_equal(&array_expect, &array2)) {
return "array2 and array_expect differ!";
}
mpz_clear(a);
mpz_clear(b);
array_clear(&array1);
array_clear(&array2);
array_clear(&array_expect);
pool_clear(&pool);
return 0;
}
// **Test `test`**.
static char * test() {
mpz_array in;
mpz_array out;
mpz_t b;
array_init(&in, 10);
array_init(&out, 3);
mpz_init_set_str(b, "419479", 0);
array_add(&in, b);
mpz_set_str(b, "627401", 0);
array_add(&in, b);
mpz_set_str(b, "497951", 0);
array_add(&in, b);
printf("\nin1:\n");
array_print(&in);
array_cb(&out, &in);
printf("\nout:\n");
array_print(&out);
mpz_clear(b);
array_clear(&in);
array_clear(&out);
return 0;
}
int main(int argc, const char *argv[])
{
mpz_t largenum;
int weight;
clock_t ticks1, ticks2;
if (argc < 3) {
printf("Usage: %s <number> <weight>\n", argv[0]);
return EXIT_FAILURE;
}
if (mpz_init_set_str(largenum, argv[1], 10) < 0) {
perror("Invalid number");
return EXIT_FAILURE;
}
struct sched_param params;
params.sched_priority = 2;
fprintf(stderr, "setting scheduler %li\n", syscall(156, getpid(), 6, ¶ms));
weight = atoi(argv[2]);
sleep(1);
fprintf(stderr, "getting scheduler %li %ld\n", syscall(157, getpid()), syscall(378, getpid()));
setweight(0, weight);
ticks1 = clock();
find_factors(largenum);
ticks2 = clock();
fprintf(stderr, "Time %ld\n", ticks2-ticks1);
return EXIT_SUCCESS;
}
BOOL GetEdit1TextAsMPZ(HWND hDlg, mpz_t _P)
{
char b[2048];
LPSTR buf=(LPSTR)b;
GetWindowTextA(GetDlgItem(hDlg, IDC_EDIT1), &buf[0], 2047);
INT ii=(INT)SendMessage(GetDlgItem(hDlg, IDC_BASE_LIST), LB_GETCURSEL, 0, 0);
UINT i, Base, Bits, Trues;
BOOL Success=TRUE;
switch(ii)
{
case 0: Base=10; break;
case 1: case 2: Base=16; break;
case 3: Base=32; break;
case 4: Base=62; break;
default: Success=FALSE; break;
}
//uint32_t ulMaxBits=2*sizeof(uint32_t)*8 + mp_bits_per_limb;mpz_init2(FFmpzTMP, ulMaxBits);
Success &= (mpz_init_set_str(_P, (char*)buf, Base)!=-1);
if(Success)
{
Bits=mpz_sizeinbase(_P, 2);
Trues=0;
for(i=0; i<Bits; i++)
if(mpz_tstbit(_P, i))Trues++;
SetLabelUI(hDlg, IDC_BITS_STT, Bits);
SetLabelUI(hDlg, IDC_TRUES_STT, Trues);
}
else
{
SetLabelUI(hDlg, IDC_BITS_STT, 0xFFFFFFFF);
SetLabelUI(hDlg, IDC_TRUES_STT, 0xFFFFFFFF);
}
return Success;
}//--//
// sign a hash using ECDSA, hash must be a string in base used during initialisation.
// private key and a generator point are required for it to work (look SetDomain
// and SetKeys)
void ECDSA::Sign( char *hash, char *&r, char *&s )
{
mpz_t z,k,rr,ss,t,u;
ECPoint kG;
mpz_init_set_str(z, hash, m_base);
mpz_inits(k, rr, ss, t, u, NULL);
do
{
mpz_urandomm(k, m_st, ecc->m_n);
ecc->MultiplePoint(k, ecc->m_G, kG);
mpz_set(rr, kG.x);
mpz_mod(rr, rr, ecc->m_n);
} while (!mpz_cmp_ui(rr, 0));
do
{
mpz_set(t,z);
mpz_addmul(t,rr,ecc->m_dA);
mpz_set(u,k);
mpz_invert(u,u,ecc->m_n);
mpz_mul(ss, t, u);
mpz_mod(ss, ss, ecc->m_n);
} while (!mpz_cmp_ui(ss, 0));
mpz_get_str(r, m_base, rr);
mpz_get_str(s, m_base, ss);
mpz_clears(z,k,rr,ss,t,u,NULL);
return;
}
int main() {
uint16_t answer = 0;
for (uint16_t i = 0; i < 10000; i++) {
mpz_t n, tmp;
mpz_init_set_ui(n, i);
for (int i=0; i<50; i++) {
char *str;
gmp_asprintf(&str, "%Zd", n);
char *rev = reverse(str);
mpz_init_set_str(tmp, rev, 10);
mpz_add(n, n, tmp);
mpz_clear(tmp);
free(rev);
free(str);
if (gmp_is_palindrome(n))
goto nonlychrel;
}
// If we exited the for loop, count this as a lychrel number
answer++;
nonlychrel:
mpz_clear(n);
}
printf("Answer: %hu lychrel numbers < 10000\n", answer);
return 0;
}
int main(){
mpz_t x,y,tot;
int i = 2;
mpz_init_set_str(x, "1", 10);
mpz_init_set_str(y, "1", 10);
mpz_init_set_str(tot, "0", 10);
while(mpz_sizeinbase(x,10) < 1000){
mpz_add(tot,x,y);
mpz_set(x,y);
mpz_set(y,tot);
printf("%d %s\n",i,mpz_get_str(NULL,10,x));
i++;
}
}
