diff --git a/.gitignore b/.gitignore
index fd55dfd..604f567 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 rsa/rsa
+rsa64/rsa
 *.swp
 *.o
 *.a
diff --git a/rsa64/Makefile b/rsa64/Makefile
index 5cbb4bb..eb4559a 100644
--- a/rsa64/Makefile
+++ b/rsa64/Makefile
@@ -3,8 +3,6 @@ NAME = rsa
 SRC = \
 	main.c \
 	rsa.c \
-	bigint.c \
-	array.c \
 	utils.c \
 	primes.c \
 
diff --git a/rsa64/array.c b/rsa64/array.c
deleted file mode 100644
index 66947aa..0000000
--- a/rsa64/array.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "rsa.h"
-
-void array_set_random_bytes(uint32_t *n, size_t size) {
-	int fd = open("/dev/urandom", O_RDONLY);
-	if (read(fd, n, size) == -1) {
-		exit(1);
-	}
-}
-
-void array_set_msb_and_lsb_to_one(uint32_t *n, size_t size) {
-	n[0] |= 1;
-	n[size / sizeof(uint32_t) - 1] |= 1 << 31;
-}
-
-void array_bitwise_right_shift(uint32_t *a, size_t len) {
-	size_t size = sizeof(uint32_t) * 8 - 1;
-	for (size_t n = 0; n < len - 1; n++) {
-		a[n] = a[n] >> 1 | (a[n + 1] & 1) << size;
-	}
-	a[len - 1] >>= 1;
-}
-
-void array_bitwise_left_shift(uint32_t *a, size_t len) {
-	size_t size = sizeof(uint32_t) * 8 - 1;
-	for (size_t n = len - 1; n > 0; n--) {
-		a[n] = a[n] << 1 | ((a[n - 1] & (1 << size)) >> size);
-	}
-	a[0] <<= 1;
-}
-
-// Will underflow
-void array_decrement(uint32_t *a, size_t len) {
-	size_t cursor = 0;
-	size_t size = sizeof(uint32_t) * 8;
-	while (cursor < size * len) {
-		a[cursor / size] = a[cursor / size] ^ (1 << (cursor % size));
-		if (((a[cursor / size] >> (cursor % size)) & 1) == 0) {
-			return;
-		}
-		cursor += 1;
-	}
-}
diff --git a/rsa64/bigint.c b/rsa64/bigint.c
deleted file mode 100644
index 415a604..0000000
--- a/rsa64/bigint.c
+++ /dev/null
@@ -1,342 +0,0 @@
-#include "rsa.h"
-
-void my_memcpy(void *dst, void *src, size_t n) {
-	memcpy(dst, src, n);
-}
-
-void bigint_set_random_bytes(bigint_t n, size_t len) {
-	int fd = open("/dev/urandom", O_RDONLY);
-	if (read(fd, n.data, len * sizeof(uint32_t)) == -1) {
-		exit(1);
-	}
-	close(fd);
-}
-
-void bigint_set_msb_and_lsb_to_one(bigint_t n, size_t len) {
-	n.data[0] |= 1;
-	n.data[len - 1] |= 1 << 31;
-}
-
-void bigint_bitwise_right_shift(bigint_t n) {
-	for (size_t i = 0; i < n.len - 1; i++) {
-		n.data[i] = n.data[i] >> 1 | (n.data[i + 1] & 1) << 31;
-	}
-	n.data[n.len - 1] >>= 1;
-}
-
-void bigint_bitwise_left_shift(bigint_t n) {
-	for (int i = n.len - 1; i > 0; i--) {
-		n.data[i] = n.data[i] << 1 | ((n.data[i - 1] & (1 << 31)) >> 31);
-	}
-	n.data[0] <<= 1;
-}
-
-void move_bigint_bitwise_left_shift(bigint_t n, bigint_t result) {
-	for (int i = result.len - 1; i > 0; i--) {
-		result.data[i] = n.data[i] << 1 | ((n.data[i - 1] & (1 << 31)) >> 31);
-	}
-	result.data[0] = n.data[0] << 1;
-}
-
-// Will underflow
-void bigint_decrement(bigint_t n) {
-	size_t cursor = 0;
-	while (cursor < n.len << 5) {
-		n.data[cursor >> 32] = n.data[cursor >> 5] ^ (1 << (cursor % 32));
-		if (((n.data[cursor >> 5] >> (cursor % 32)) & 1) == 0) {
-			return;
-		}
-		cursor += 1;
-	}
-}
-
-// TODO refactor/clean assume same length ?
-int64_t bigint_cmp(bigint_t a, bigint_t b) {
-	int cursor = a.len - 1;
-	while (cursor >= 0) {
-		if (a.data[cursor] > b.data[cursor]) {
-			return 1;
-		}
-		if (b.data[cursor] > a.data[cursor]) {
-			return -1;
-		}
-		cursor -= 1;
-	}
-
-	return 0;
-}
-
-// TODO refactor/clean assume same length ?
-int bigint_dif(bigint_t a, bigint_t b) {
-	int cursor = a.len;
-	while (--cursor >= 0) {
-		if (a.data[cursor] ^ b.data[cursor]) {
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-int is_zero(bigint_t n) {
-	for (size_t i = 0; i < n.len; i++) {
-		if (n.data[i]) {
-			return 0;
-		}
-	}
-	return 1;
-}
-
-// TODO check opti
-void bigint_substraction(bigint_t a, bigint_t b, bigint_t borrow, bigint_t y) {
-	my_memcpy(y.data, b.data, b.len * sizeof(uint32_t));
-	while (!is_zero(y)) {
-		for (size_t i = 0; i < a.len; i++) {
-			borrow.data[i] = ~a.data[i] & y.data[i];
-			a.data[i] = a.data[i] ^ y.data[i];
-		}
-		move_bigint_bitwise_left_shift(borrow, y);
-	}
-}
-
-// TODO check opti
-void custom_bigint_modulo(bigint_t a, bigint_t b, bigint_t result, bigint_t mod, bigint_t borrow_sub, bigint_t y_sub) {
-	bigint_set_zeros(result);
-	my_memcpy(result.data, a.data, a.len * sizeof(uint32_t));
-	if (bigint_cmp(result, b) < 0) {
-		return ;
-	}
-	while (bigint_cmp(result, mod) > 0) {
-		bigint_bitwise_left_shift(mod);
-	}
-	while (bigint_cmp(b, mod) < 0) {
-		bigint_bitwise_right_shift(mod);
-		if (bigint_cmp(result, mod) > 0) {
-			bigint_substraction(result, mod, borrow_sub, y_sub);
-		}
-	}
-	while (bigint_cmp(result, b) > -1) {
-		bigint_substraction(result, b, borrow_sub, y_sub);
-	}
-}
-
-bigint_t bigint_new(size_t len) {
-	bigint_t bigint;
-
-	bigint.len = len;
-	bigint.data = (uint32_t *)protected_malloc(len * sizeof(uint32_t));
-
-	return bigint;
-}
-
-bigint_t bigint_zero(size_t len) {
-	bigint_t bigint;
-
-	bigint = bigint_new(len);
-	for (size_t i = 0; i < len; i++) {
-		bigint.data[i] = 0;
-	}
-
-	return bigint;
-}
-
-bigint_t bigint_clone(bigint_t src) {
-	bigint_t dst;
-
-	dst.len = src.len;
-	dst.data = (uint32_t *)protected_malloc(src.len * sizeof(uint32_t));
-	my_memcpy(dst.data, src.data, src.len * sizeof(uint32_t));
-
-	return dst;
-}
-
-void bigint_destroy(bigint_t n) {
-	free(n.data);
-	n.data = NULL;
-}
-
-void custom_bigint_add(bigint_t a, bigint_t b, int index) {
-	uint64_t carriage = 0;
-
-	for (size_t cursor = 0; cursor < a.len; cursor++) {
-		uint64_t tmp = (uint64_t)a.data[cursor] + carriage;
-		if ((int)cursor - index >= 0) {
-			tmp += (uint64_t)b.data[cursor - index];
-		}
-		a.data[cursor] = (uint32_t)tmp;
-		carriage = tmp >> 32;
-	}
-}
-
-void bigint_set_zeros(bigint_t n) {
-	for (size_t i = 0; i < n.len; i++) {
-		n.data[i] = 0;
-	}
-}
-
-void custom_bigint_mul(bigint_t a, bigint_t b, bigint_t result, bigint_t *b_tool) {
-	int width = a.len * 32;
-	bigint_set_zeros(result);
-	bigint_set_zeros(b_tool[0]);
-	my_memcpy(b_tool[0].data, b.data, b.len * sizeof(uint32_t));
-
-	for (int i = 1; i < 32; i++) {
-		bigint_set_zeros(b_tool[i]);
-		my_memcpy(b_tool[i].data, b_tool[i - 1].data, b.len * sizeof(uint32_t));
-		bigint_bitwise_left_shift(b_tool[i]);
-	}
-
-	for (int cursor = 0; cursor < width; cursor++) {
-		int offset = cursor % 32;
-		int index = cursor >> 5;
-		if (a.data[index] >> offset & 1) {
-			custom_bigint_add(result, b_tool[offset], index);
-		}
-	}
-}
-
-// a^e mod n
-// clean memory tricks !!!
-void custom_bigint_pow_mod(bigint_t a, bigint_t e, bigint_t n, bigint_t result, bigint_t custom, bigint_t custom2, bigint_t mod, bigint_t borrow_sub, bigint_t y_sub, bigint_t *b_tool) {
-	bigint_set_zeros(result);
-	bigint_set_zeros(custom);
-	bigint_set_zeros(custom2);
-	my_memcpy(result.data, a.data, a.len * sizeof(uint32_t));
-	int cursor = (e.len << 5) - 1;
-	while (!(e.data[cursor >> 5] & 1 << (cursor % 32))) {
-		cursor--;
-	}
-	cursor--;
-	while (cursor >= 0) {
-		custom_bigint_mul(result, result, custom, b_tool);
-		custom_bigint_modulo(custom, n, custom2, mod, borrow_sub, y_sub);
-		bigint_set_zeros(result);
-		my_memcpy(result.data, custom2.data, custom2.len * sizeof(uint32_t));
-		if (e.data[cursor >> 5] & 1 << (cursor % 32)) {
-			custom_bigint_mul(result, a, custom, b_tool);
-			custom_bigint_modulo(custom, n, custom2, mod, borrow_sub, y_sub);
-			my_memcpy(result.data, custom2.data, custom2.len * sizeof(uint32_t));
-		}
-		cursor -= 1;
-	}
-}
-
-void bigint_print(bigint_t n) {
-	for (int i = n.len - 1; i >= 0; i--) {
-		printf("bigint %ud\n", n.data[i]);
-	}
-}
-
-
-void bulk_destroy(bigint_t x, bigint_t y, bigint_t n, bigint_t d, bigint_t two, bigint_t one, bigint_t n_minus_two, bigint_t n_minus_one) {
-	bigint_destroy(x);
-	bigint_destroy(y);
-	bigint_destroy(n);
-	bigint_destroy(d);
-	bigint_destroy(two);
-	bigint_destroy(one);
-	bigint_destroy(n_minus_two);
-	bigint_destroy(n_minus_one);
-}
-
-int prime_division(bigint_t *primes, bigint_t n, bigint_t mod, bigint_t custom2, bigint_t borrow_sub, bigint_t y_sub) {
-	bigint_set_zeros(mod);
-	for (int i = 0; i < 200; i++) {
-		mod.data[0] = primes[i].data[0];
-		custom_bigint_modulo(n, primes[i], custom2, mod, borrow_sub, y_sub);
-		if (is_zero(custom2)) {
-			return 1;
-		}
-	}
-	return 0;
-}
-
-int miller_rabin(size_t len, bigint_t a, bigint_t two, bigint_t n_minus_two, bigint_t d, bigint_t n, bigint_t x, bigint_t custom, bigint_t custom2, bigint_t mod, bigint_t borrow_sub, bigint_t y_sub, bigint_t *b_tool, bigint_t n_minus_one, uint32_t s, bigint_t y, bigint_t one) {
-	for (uint32_t k = 0; k < 20; k++) {
-		bigint_set_zeros(a);
-		while (bigint_cmp(a, two) < 0 || bigint_cmp(a, n_minus_two) > 0) {
-			bigint_set_random_bytes(a, len);
-		}
-		custom_bigint_pow_mod(a, d, n, x, custom, custom2, mod, borrow_sub, y_sub, b_tool);
-		for (uint32_t i = 0; i < s; i++) {
-			custom_bigint_pow_mod(x, two, n, y, custom, custom2, mod, borrow_sub, y_sub, b_tool);
-			if (!bigint_dif(y, one) && bigint_dif(x, one) && bigint_dif(x, n_minus_one)) {
-				return 0;
-			}
-			bigint_destroy(x);
-			x = bigint_clone(y);
-		}
-		if (bigint_dif(y, one)) {
-			return 0;
-		}
-	}
-	return 1;
-}
-
-bigint_t bigint_prime(size_t len, bigint_t *primes) {
-	size_t my_size = len * 2;
-
-	bigint_t n = bigint_zero(my_size);
-
-	bigint_set_random_bytes(n, len);
-	bigint_set_msb_and_lsb_to_one(n, len);
-	bigint_t mod = bigint_clone(n);
-	bigint_t borrow_sub = bigint_clone(n);
-	bigint_t y_sub = bigint_clone(n);
-	bigint_t d = bigint_clone(n);
-	d.data[0] -= 1;
-	uint32_t s = 0;
-	while (!(d.data[0] & 1)) {
-		bigint_bitwise_right_shift(d);
-		s += 1;
-	}
-
-	bigint_t x = bigint_zero(my_size);
-	bigint_t y = bigint_zero(my_size);
-	bigint_t custom = bigint_zero(my_size);
-	bigint_t custom2 = bigint_zero(my_size);
-
-
-	if (prime_division(primes, n, mod, custom2, borrow_sub, y_sub)) {
-		bulk_destroy(x, y, n, d, custom, custom2, mod, borrow_sub);
-		bigint_destroy(y_sub);		
-		return bigint_prime(len, primes);
-	}
-	memcpy(mod.data, n.data, n.len * sizeof(uint32_t));
-
-	bigint_t *b_tool = (bigint_t *)protected_malloc(32 * sizeof(bigint_t));
-	for (int i = 0; i < 32; i++) {
-		b_tool[i] = bigint_zero(my_size * 2);
-	}
-
-	bigint_t two = bigint_zero(my_size);
-	bigint_t one = bigint_zero(my_size);
-	two.data[0] = 2;
-	one.data[0] = 1;
-	bigint_t n_minus_two = bigint_clone(n);
-	bigint_t n_minus_one = bigint_clone(n);
-	n_minus_two.data[0] -= 1;
-	n_minus_one.data[0] -= 1;
-	bigint_decrement(n_minus_two);
-	bigint_t a = bigint_zero(my_size);
-
-	int is_prime =  miller_rabin(len, a, two, n_minus_two, d, n, x, custom, custom2, mod, borrow_sub, y_sub, b_tool, n_minus_one, s, y, one);
-
-	bulk_destroy(x, y, custom, d, two, one, n_minus_two, n_minus_one);
-	bigint_destroy(custom2);
-	bigint_destroy(a);
-	bigint_destroy(mod);
-	bigint_destroy(borrow_sub);
-	bigint_destroy(y_sub);
-	for (int i = 0; i < 32; i++) {
-		bigint_destroy(b_tool[i]);
-	}
-	free(b_tool);
-
-	if (is_prime) {
-		return n;
-	}
-	bigint_destroy(n);
-	return bigint_prime(len, primes);
-}
-
diff --git a/rsa64/rsa.c b/rsa64/rsa.c
index 45ae45c..ce066ff 100644
--- a/rsa64/rsa.c
+++ b/rsa64/rsa.c
@@ -1,22 +1,22 @@
 #include "rsa.h"
-
+/*
 rsa_t rsa_init(size_t len, bigint_t *primes) {
 	rsa_t rsa;
 
 //	printf("Generating two primes of length %d bits\n", RSA_BLOCK_SIZE / 2);
 	//printf("Generating p...\n");
-	rsa.p = bigint_prime(len / 2, primes);
+//	rsa.p = bigint_prime(len / 2, primes);
 //	printf("p = %lu\n", ((uint64_t)rsa.p.data[1] << 32) + (uint64_t)rsa.p.data[0]);
 //printf("p = %u\n", rsa.p.data[0]);
 	//printf("Generating q...\n");
-	rsa.q = bigint_prime(len / 2, primes);
+//	rsa.q = bigint_prime(len / 2, primes);
 //	printf("q = %lu\n", ((uint64_t)rsa.q.data[1] << 32) + (uint64_t)rsa.q.data[0]);
 	//printf("q = %u\n", rsa.q.data[0]);
 
 
 	return rsa;
 }
-
+*/
 int64_t euler(int64_t r0, int64_t r1) {
 	int64_t s0 = 1;
 	int64_t s1 = 0;
@@ -71,27 +71,28 @@ int64_t euler2(int64_t r0, int64_t r1) {
 	return t0;
 }
 rsa_t rsa_generate_keys(size_t block_size) {
-	size_t len = block_size / sizeof(uint32_t) / 8;
-	bigint_t *primes = (bigint_t *)protected_malloc(3245 * sizeof(bigint_t));
-	for (int i = 0; i < 3245; i++) {
-		primes[i] = bigint_zero(len);
-	}
-	int fd = open("primes.0000", O_RDONLY);
-	char *buf = (char *)malloc(21290 * sizeof(char));
-	int ret = read(fd, buf, 21290);
-	char *tok = strtok(buf, "\n");
-	int i = 0;
-	while (tok) {
-		primes[i].data[0] = (uint32_t)atoi(tok);
-		tok = strtok(NULL, "\n");
-		i += 1;
-	}
-	primes[0].data[0] = 65537;
-	printf("ret %d\n", ret);
+	(void)block_size;
+//	size_t len = block_size / sizeof(uint32_t) / 8;
+//	bigint_t *primes = (bigint_t *)protected_malloc(3245 * sizeof(bigint_t));
+//	for (int i = 0; i < 3245; i++) {
+//		primes[i] = bigint_zero(len);
+//	}
+//	int fd = open("primes.0000", O_RDONLY);
+//	char *buf = (char *)malloc(21290 * sizeof(char));
+//	int ret = read(fd, buf, 21290);
+//	char *tok = strtok(buf, "\n");
+//	int i = 0;
+//	while (tok) {
+//		primes[i].data[0] = (uint32_t)atoi(tok);
+//		tok = strtok(NULL, "\n");
+//		i += 1;
+//	}
+//	primes[0].data[0] = 65537;
+//	printf("ret %d\n", ret);
 
-	rsa_t rsa = rsa_init(len, primes);
-	bigint_destroy(rsa.p);
-	bigint_destroy(rsa.q);
+//	rsa_t rsa = rsa_init(len, primes);
+//	bigint_destroy(rsa.p);
+//	bigint_destroy(rsa.q);
 
 	//int64_t p = 56843;//(uint64_t)generate_prime();
 	//int64_t q = 61861;//(uint64_t)generate_prime();
@@ -187,6 +188,8 @@ rsa_t rsa_generate_keys(size_t block_size) {
 	printf("decrypted: %ld\n", m2);
 	}*/
 	}
+	rsa_t rsa;
+	rsa.p.len = 42;
 	return rsa;
 }