diff --git a/Makefile b/Makefile
index 2c8163f..2a0f833 100644
--- a/Makefile
+++ b/Makefile
@@ -1,9 +1,10 @@
 .PHONY: all clean test cpptest verify quick-verify
 
 CXX=         g++
-CXXFLAGS=    -g -Wall -Wno-unused-function -std=c++17 -O2
+CXXFLAGS=    -g -Wall -Wno-unused-function -std=c++17 -O3
 LDFLAGS=     -lz -lpthread
 SRC=         src
+UINT256=     $(SRC)/uint256_t
 SCRIPTS=     scripts
 DATA=        data
 TESTS=       tests
@@ -24,13 +25,13 @@ verify: $(PROG) $(SCRIPTS)/verify.py $(DATA)/spneumoniae.fa
 quick-verify: $(PROG) $(SCRIPTS)/verify.py $(DATA)/spneumoniae.fa
 	python $(SCRIPTS)/verify.py $(DATA)/spneumoniae.fa --quick --interpath $(DATA)/spyogenes.fa
 
-$(PROG): $(SRC)/main.cpp $(SRC)/$(wildcard *.cpp *.h *.hpp) src/version.h
+$(PROG): $(SRC)/main.cpp $(SRC)/$(wildcard *.cpp *.h *.hpp) src/version.h $(wildcard $(UINT256)/*.cpp $(UINT256)/*.h $(UINT256)/*.include)
 	./create-version.sh
 	$(CXX) $(CXXFLAGS) $(SRC)/main.cpp $(SRC)/kthread.c -o $@ $(LDFLAGS)
 
 
 prophasmtest: $(TESTS)/unittest.cpp gtest-all.o $(SRC)/$(wildcard *.cpp *.h *.hpp) $(TESTS)/$(wildcard *.cpp *.h *.hpp)
-	$(CXX) $(CXXFLAGS) -isystem $(GTEST)/include -I $(GTEST)/include $(TESTS)/unittest.cpp gtest-all.o -pthread -o $@ $(LDFLAGS)
+	$(CXX) $(CXXFLAGS) -isystem $(GTEST)/include -I $(GTEST)/include $(TESTS)/unittest.cpp  gtest-all.o -pthread -o $@ $(LDFLAGS)
 
 gtest-all.o: $(GTEST)/src/gtest-all.cc $(wildcard *.cpp *.h *.hpp)
 	$(CXX) $(CXXFLAGS) -isystem $(GTEST)/include -I $(GTEST)/include -I $(GTEST) -DGTEST_CREATE_SHARED_LIBRARY=1 -c -pthread $(GTEST)/src/gtest-all.cc -o $@
diff --git a/README.md b/README.md
index 73fdd41..2ea85c7 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ ProphAsm2 is a versatile tool for computing simplitigs/SPSS
 from *k-mer sets* and for *k-mer set operations*.
 The new features compared to the original [ProphAsm](https://github.com/prophyle/prophasm)
 include a largely speed and memory optimization, parallelization,
-support for k-mer sizes up to 64 and support for minimum abundances.
+support for k-mer sizes up to 128 and support for minimum abundances.
 
 Various types of sequencing datasets can be used as the input for
 ProphAsm, including genomes, pan-genomes, metagenomes or sequencing reads.
@@ -74,8 +74,19 @@ Set operations:
 USAGE-BEGIN
 -->
 ```
-
-
+Usage:    prophasm2 [options]
+Command-line parameters:
+ -k INT   K-mer size.
+ -i FILE  Input FASTA file (can be used multiple times).
+ -o FILE  Output FASTA file (if used, must be used as many times as -i).
+ -x FILE  Compute intersection, subtract it, save it.
+ -s FILE  Output file with k-mer statistics.
+ -t INT   Number of threads (default 1).
+ -m INT   Minimum abundance of k-mers to appear in the assembly (default 1).
+ -S       Silent mode.
+ -u       Do not consider k-mer and its reverse complement as equivalent.
+
+Note that '-' can be used for standard input/output. 
 ```
 <!---
 USAGE-END
diff --git a/scripts/verify.py b/scripts/verify.py
index e96abbd..2ac1669 100755
--- a/scripts/verify.py
+++ b/scripts/verify.py
@@ -102,14 +102,14 @@ def main():
         print("Testing ProphAsm2 outputs valid intersection on files " + args.path + " and " + args.interpath)
         for complements in [True]:
             for m in range(1, 3):
-                for k in range(2, 65, 23 if args.quick else 1):
+                for k in range(2, 129, 23 if args.quick else 1):
                     success &= verify_intersection(args.path, args.interpath, k, complements, m)
                 print("")
 
     print("Testing ProphAsm2 outputs valid simplitigs on file " + args.path)
     for complements in [True, False]:
         for m in range(1, 4):
-            for k in range(2, 65, 11 if args.quick else 1):
+            for k in range(2, 129, 11 if args.quick else 1):
                 success &= verify_instance(args.path, k, complements, m)
             print("")
 
diff --git a/src/khash.h b/src/khash.h
index f75f347..59453d4 100644
--- a/src/khash.h
+++ b/src/khash.h
@@ -159,7 +159,7 @@ typedef unsigned long long khint64_t;
 #endif
 #endif /* klib_unused */
 
-typedef khint32_t khint_t;
+typedef khint64_t khint_t;
 typedef khint_t khiter_t;
 
 #define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
@@ -176,6 +176,10 @@ typedef khint_t khiter_t;
 #define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
 #endif
 
+#ifndef kroundup64
+#define kroundup64(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, (x)|=(x)>>32, ++(x))
+#endif
+
 #ifndef kcalloc
 #define kcalloc(N,Z) calloc(N,Z)
 #endif
@@ -246,7 +250,7 @@ static const double __ac_HASH_UPPER = 0.77;
 		khint32_t *new_flags = 0;										\
 		khint_t j = 1;													\
 		{																\
-			kroundup32(new_n_buckets); 									\
+			kroundup64(new_n_buckets); 									\
 			if (new_n_buckets < 4) new_n_buckets = 4;					\
 			if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0;	/* requested size is too small */ \
 			else { /* hash table size to be changed (shrink or expand); rehash */ \
@@ -382,7 +386,8 @@ static const double __ac_HASH_UPPER = 0.77;
   @param  key   The integer [khint64_t]
   @return       The hash value [khint_t]
  */
-#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
+//#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
+#define kh_int64_hash_func(key) (khint64_t)(__ac_Wang_hash(key))
 /*! @function
   @abstract     64-bit integer comparison function
  */
diff --git a/src/khash_utils.h b/src/khash_utils.h
index 648faaa..9070a9b 100644
--- a/src/khash_utils.h
+++ b/src/khash_utils.h
@@ -6,21 +6,22 @@
 #include "kmers.h"
 #include "khash.h"
 
+typedef unsigned char byte;
 
 #define kh_int128_hash_func(key) kh_int64_hash_func((khint64_t)((key)>>65^(key)^(key)<<21))
 #define kh_int128_hash_equal(a, b) ((a) == (b))
+#define kh_int256_hash_func(key) kh_int128_hash_func((__uint128_t)((key)>>129^(key)^(key)<<35))
+#define kh_int256_hash_equal(a, b) ((a) == (b))
 
 #define KHASH_MAP_INIT_INT128(name, khval_t)								\
 	KHASH_INIT(name, __uint128_t, khval_t, 1, kh_int128_hash_func, kh_int128_hash_equal)
 
-#define KHASH_SET_INIT_INT128(name)										\
-	KHASH_INIT(name, __uint128_t, char, 0, kh_int128_hash_func, kh_int128_hash_equal)
-
-typedef unsigned char byte;
+#define KHASH_MAP_INIT_INT256(name, khval_t)								\
+	KHASH_INIT(name, uint256_t, khval_t, 1, kh_int256_hash_func, kh_int128_hash_equal)
 
+KHASH_MAP_INIT_INT256(S256M, byte)
 KHASH_MAP_INIT_INT128(S128M, byte)
 KHASH_MAP_INIT_INT64(S64M, byte)
-KHASH_SET_INIT_INT128(S128S)
 KHASH_SET_INIT_INT64(S64S)
 
 byte MINIMUM_ABUNDANCE = 1;
@@ -40,26 +41,35 @@ struct DifferenceInPlaceData##variant {
 };                                                                                                                  \
                                                                                                                     \
 /* Determine whether the canonical k-mer is present.*/                                                              \
-bool containsKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool complements) {                         \
-    if (complements) kMer = CanonicalKMer(kMer, k);                                                                 \
+inline bool containsCanonicalKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer) {                                  \
     bool contains_key = kh_get_S##variant(kMers, kMer) != kh_end(kMers);                                            \
     if (MINIMUM_ABUNDANCE == 1) return contains_key;                                                                \
     if (!contains_key) return false;                                                                                \
     return kh_val(kMers, kh_get_S##variant(kMers, kMer)) >= MINIMUM_ABUNDANCE;                                      \
 }                                                                                                                   \
                                                                                                                     \
-/* Remove the canonical k-mer from the set.*/                                                                       \
-void eraseKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool complements) {                            \
+/* Determine whether the canonical form of a k-mer is present.*/                                                    \
+inline bool containsKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool complements) {                  \
     if (complements) kMer = CanonicalKMer(kMer, k);                                                                 \
+    return containsCanonicalKMer(kMers, kMer);                                                                      \
+}                                                                                                                   \
+                                                                                                                    \
+/* Remove the canonical k-mer from the set.*/                                                                       \
+inline void eraseCanonicalKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer) {                                     \
     auto key = kh_get_S##variant(kMers, kMer);                                                                      \
     if (key != kh_end(kMers)) {                                                                                     \
         kh_del_S##variant(kMers, key);                                                                              \
     }                                                                                                               \
 }                                                                                                                   \
                                                                                                                     \
-/* Insert the canonical k-mer into the set. */                                                                      \
-void insertKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool complements, bool force = false) {       \
+/* Remove the canonical form of a k-mer from the set.*/                                                             \
+inline void eraseKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool complements) {                     \
     if (complements) kMer = CanonicalKMer(kMer, k);                                                                 \
+    eraseCanonicalKMer(kMers, kMer);                                                                                \
+}                                                                                                                   \
+                                                                                                                    \
+/* Insert the canonical k-mer into the set. */                                                                      \
+inline void insertCanonicalKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, bool force=false) {                  \
     int ret;                                                                                                        \
     if (MINIMUM_ABUNDANCE == (byte)1) {                                                                             \
         kh_put_S##variant(kMers, kMer, &ret);                                                                       \
@@ -76,6 +86,12 @@ void insertKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool compl
     }                                                                                                               \
 }                                                                                                                   \
                                                                                                                     \
+/* Insert the canonical k-mer into the set. */                                                                      \
+inline void insertKMer(kh_S##variant##_t *kMers, kmer##type##_t kMer, int k, bool complements, bool force=false) {  \
+    if (complements) kMer = CanonicalKMer(kMer, k);                                                                 \
+    insertCanonicalKMer(kMers, kMer, force);                                                                        \
+}                                                                                                                   \
+                                                                                                                    \
 /* Parallel wrapper for differenceInPlace. */                                                                       \
 void DifferenceInPlaceThread##variant(void *arg, long i, int _) {                                                   \
     auto data = (DifferenceInPlaceData##variant*)arg;                                                               \
@@ -84,12 +100,12 @@ void DifferenceInPlaceThread##variant(void *arg, long i, int _) {
 
 INIT_KHASH_UTILS(64, 64S)
 INIT_KHASH_UTILS(64, 64M)
-INIT_KHASH_UTILS(128, 128S)
 INIT_KHASH_UTILS(128, 128M)
+INIT_KHASH_UTILS(256, 256M)
 
 /// Return the next k-mer in the k-mer set and update the index.
 template <typename KHT, typename kmer_t>
-kmer_t nextKMer(KHT *kMers, size_t &lastIndex, kmer_t &kMer) {
+inline kmer_t nextKMer(KHT *kMers, size_t &lastIndex, kmer_t &kMer) {
     for (size_t i = kh_begin(kMers) + lastIndex; i != kh_end(kMers); ++i, ++lastIndex) {
         if (!kh_exist(kMers, i)) continue;
         kMer = kh_key(kMers, i);
@@ -116,7 +132,7 @@ std::vector<kmer64_t> kMersToVec(kh_S64M_t *kMers) {
 
 /// Compute the intersection of several k-mer sets.
 template <typename KHT>
-KHT *getIntersection(KHT* result, std::vector<KHT*> &kMerSets, int k, bool complements) {
+KHT *getIntersection(KHT* result, std::vector<KHT*> &kMerSets) {
     if (kMerSets.size() < 2) return result;
     KHT* smallestSet = kMerSets[0];
     for (size_t i = 1; i < kMerSets.size(); ++i) {
@@ -125,16 +141,16 @@ KHT *getIntersection(KHT* result, std::vector<KHT*> &kMerSets, int k, bool compl
     for (auto i = kh_begin(smallestSet); i != kh_end(smallestSet); ++i) {
         if (!kh_exist(smallestSet, i)) continue;
         auto kMer = kh_key(smallestSet, i);
-        if (!containsKMer(smallestSet, kMer, k, complements)) continue;
+        if (!containsCanonicalKMer(smallestSet, kMer)) continue;
         bool everywhere = true;
         for (size_t i = 0; i < kMerSets.size(); ++i) if (kMerSets[i] != smallestSet) {
-            if (!containsKMer(kMerSets[i], kMer, k, complements)) {
+            if (!containsCanonicalKMer(kMerSets[i], kMer)) {
                 everywhere = false;
                 break;
             }
         }
         if (everywhere) {
-            insertKMer(result, kMer, k, complements, true);
+            insertCanonicalKMer(result, kMer, true);
         }
     }
     return result;
diff --git a/src/kmers.h b/src/kmers.h
index 996d115..5f57b80 100644
--- a/src/kmers.h
+++ b/src/kmers.h
@@ -4,12 +4,15 @@
 #include <iostream>
 #include <cstdint>
 
+#include "uint256_t/uint256_t.h"
+
 typedef uint64_t kmer64_t;
 typedef __uint128_t kmer128_t;
+typedef uint256_t kmer256_t;
 
 /// Convert the given basic nucleotide to int so it can be used for indexing in AC.
 /// If non-existing nucleotide is given, return -1.
-int NucleotideToInt (char c) {
+inline int NucleotideToInt (char c) {
     switch (c) {
         case 'A': return 0;
         case 'C': return 1;
@@ -25,13 +28,13 @@ int NucleotideToInt (char c) {
 
 /// Compute the prefix of size d of the given k-mer.
 template <typename kmer_t>
-kmer_t BitPrefix(kmer_t kMer, int k, int d) {
+inline kmer_t BitPrefix(kmer_t kMer, int k, int d) {
     return kMer >> ((k - d) << kmer_t(1));
 }
 
 /// Compute the suffix of size d of the given k-mer.
 template <typename kmer_t>
-kmer_t BitSuffix(kmer_t kMer, int d) {
+inline kmer_t BitSuffix(kmer_t kMer, int d) {
     return kMer & ((kmer_t(1) << (d << kmer_t(1))) - kmer_t(1));
 }
 
@@ -71,9 +74,17 @@ inline kmer128_t word_reverse_complement(kmer128_t w) {
     w = ( w >> 64                   ) | ( w                    << 64);
     return ((U)-1) - w;
 }
+/// Compute the reverse complement of a word.
+/// Copyright: Jellyfish GPL-3.0
+inline kmer256_t word_reverse_complement(kmer256_t w) {
+    kmer128_t low = word_reverse_complement(w.lower());
+    kmer128_t high = word_reverse_complement(w.upper());
+    return kmer256_t(low, high);
+}
 
 constexpr int KMER_SIZE_64 = 64;
 constexpr int KMER_SIZE_128 = 128;
+constexpr int KMER_SIZE_256 = 256;
 #define INIT_KMERS(type)                                                                                                              \
                                                                                                                                       \
 /* Get the mask to mask k-mers. */                                                                                                    \
@@ -89,6 +100,7 @@ inline kmer##type##_t ReverseComplement(kmer##type##_t kMer, int k) {
 
 INIT_KMERS(64)
 INIT_KMERS(128)
+INIT_KMERS(256)
 
 /// Return the lexicographically smaller of the k-mer and its reverse complement.
 template <typename kmer_t>
@@ -102,7 +114,7 @@ const char letters[4] {'A', 'C', 'G', 'T'};
 /// Return the index-th nucleotide from the encoded k-mer.
 template <typename kmer_t>
 inline char NucleotideAtIndex(kmer_t encoded, int k, int index) {
-    return letters[(encoded >> ((k - index - kmer_t(1)) << kmer_t(1))) & kmer_t(3)];
+    return letters[(uint32_t)(encoded >> ((k - index - kmer_t(1)) << kmer_t(1))) & kmer_t(3)];
 }
 
 /// Convert the encoded KMer representation to string.
@@ -111,7 +123,7 @@ std::string NumberToKMer(kmer_t encoded, int length) {
     std::string ret(length, 'N');
     for (int i = 0; i < length; ++i) {
         // The last two bits correspond to one nucleotide.
-        ret[length - i -1] = letters[encoded & 3];
+        ret[length - i -1] = letters[(uint32_t)(encoded & 3)];
         // Move to the next letter.
         encoded >>= 2;
     }
diff --git a/src/kthread.c b/src/kthread.c
index ffdf940..6994242 100644
--- a/src/kthread.c
+++ b/src/kthread.c
@@ -1,3 +1,7 @@
+/* The MIT License
+
+   Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
+   */
 #include <pthread.h>
 #include <stdlib.h>
 #include <limits.h>
@@ -69,91 +73,4 @@ void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n)
 		long j;
 		for (j = 0; j < n; ++j) func(data, j, 0);
 	}
-}
-
-/*****************
- * kt_pipeline() *
- *****************/
-
-struct ktp_t;
-
-typedef struct {
-	struct ktp_t *pl;
-	int64_t index;
-	int step;
-	void *data;
-} ktp_worker_t;
-
-typedef struct ktp_t {
-	void *shared;
-	void *(*func)(void*, int, void*);
-	int64_t index;
-	int n_workers, n_steps;
-	ktp_worker_t *workers;
-	pthread_mutex_t mutex;
-	pthread_cond_t cv;
-} ktp_t;
-
-static void *ktp_worker(void *data)
-{
-	ktp_worker_t *w = (ktp_worker_t*)data;
-	ktp_t *p = w->pl;
-	while (w->step < p->n_steps) {
-		// test whether we can kick off the job with this worker
-		pthread_mutex_lock(&p->mutex);
-		for (;;) {
-			int i;
-			// test whether another worker is doing the same step
-			for (i = 0; i < p->n_workers; ++i) {
-				if (w == &p->workers[i]) continue; // ignore itself
-				if (p->workers[i].step <= w->step && p->workers[i].index < w->index)
-					break;
-			}
-			if (i == p->n_workers) break; // no workers with smaller indices are doing w->step or the previous steps
-			pthread_cond_wait(&p->cv, &p->mutex);
-		}
-		pthread_mutex_unlock(&p->mutex);
-
-		// working on w->step
-		w->data = p->func(p->shared, w->step, w->step? w->data : 0); // for the first step, input is NULL
-
-		// update step and let other workers know
-		pthread_mutex_lock(&p->mutex);
-		w->step = w->step == p->n_steps - 1 || w->data? (w->step + 1) % p->n_steps : p->n_steps;
-		if (w->step == 0) w->index = p->index++;
-		pthread_cond_broadcast(&p->cv);
-		pthread_mutex_unlock(&p->mutex);
-	}
-	pthread_exit(0);
-}
-
-void kt_pipeline(int n_threads, void *(*func)(void*, int, void*), void *shared_data, int n_steps)
-{
-	ktp_t aux;
-	pthread_t *tid;
-	int i;
-
-	if (n_threads < 1) n_threads = 1;
-	aux.n_workers = n_threads;
-	aux.n_steps = n_steps;
-	aux.func = func;
-	aux.shared = shared_data;
-	aux.index = 0;
-	pthread_mutex_init(&aux.mutex, 0);
-	pthread_cond_init(&aux.cv, 0);
-
-	aux.workers = (ktp_worker_t*)calloc(n_threads, sizeof(ktp_worker_t));
-	for (i = 0; i < n_threads; ++i) {
-		ktp_worker_t *w = &aux.workers[i];
-		w->step = 0; w->pl = &aux; w->data = 0;
-		w->index = aux.index++;
-	}
-
-	tid = (pthread_t*)calloc(n_threads, sizeof(pthread_t));
-	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktp_worker, &aux.workers[i]);
-	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
-	free(tid); free(aux.workers);
-
-	pthread_mutex_destroy(&aux.mutex);
-	pthread_cond_destroy(&aux.cv);
-}
+}
\ No newline at end of file
diff --git a/src/kthread.h b/src/kthread.h
index c3cd165..1f5b480 100644
--- a/src/kthread.h
+++ b/src/kthread.h
@@ -6,7 +6,6 @@ extern "C" {
 #endif
 
 void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n);
-void kt_pipeline(int n_threads, void *(*func)(void*, int, void*), void *shared_data, int n_steps);
 
 #ifdef __cplusplus
 }
diff --git a/src/main.cpp b/src/main.cpp
index 8334951..6a1fc1a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -9,7 +9,7 @@
 #include "khash_utils.h"
 
 
-constexpr int MAX_K = 64;
+constexpr int MAX_K = 128;
 
 
 int Help() {
@@ -109,7 +109,7 @@ int run##version(int32_t k,
         if (verbose) {                                                                                                  \
             std::cerr << "2.1) Computing intersection" << std::endl;                                                    \
         }                                                                                                               \
-        getIntersection(intersection, fullSets, k, complements);                                                        \
+        getIntersection(intersection, fullSets);                                                                        \
         intersectionSize  = kh_size(intersection);                                                                      \
         if (verbose) {                                                                                                  \
             std::cerr << "   intersection size: " <<  intersectionSize << std::endl;                                    \
@@ -198,8 +198,8 @@ int run##version(int32_t k,
 
 INIT_RUN(64, 64S)
 INIT_RUN(64, 64M)
-INIT_RUN(128, 128S)
 INIT_RUN(128, 128M)
+INIT_RUN(256, 256M)
 
 int main(int argc, char **argv) {
     int32_t k = -1;
@@ -329,11 +329,9 @@ int main(int argc, char **argv) {
         } else {
             return run64M(k, intersectionPath, inPaths, outPaths, statsPath, fstats, computeIntersection, computeOutput, verbose, complements, threads, setCount);
         }
+    } else if (k <= 64) {
+        return run128M(k, intersectionPath, inPaths, outPaths, statsPath, fstats, computeIntersection, computeOutput, verbose, complements, threads, setCount);
     } else {
-        if (MINIMUM_ABUNDANCE == (byte)1) {
-            return run128S(k, intersectionPath, inPaths, outPaths, statsPath, fstats, computeIntersection, computeOutput, verbose, complements, threads, setCount);
-        } else {
-            return run128M(k, intersectionPath, inPaths, outPaths, statsPath, fstats, computeIntersection, computeOutput, verbose, complements, threads, setCount);
-        }
+        return run256M(k, intersectionPath, inPaths, outPaths, statsPath, fstats, computeIntersection, computeOutput, verbose, complements, threads, setCount);
     }
 }
diff --git a/src/parser.h b/src/parser.h
index 97aaf42..77ab501 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -32,6 +32,7 @@ void ReadKMers(kh_S##variant##_t *kMers, std::string &path, int k, bool compleme
     char c;                                                                                               \
     int beforeKMerEnd = k;                                                                                \
     kmer##type##_t currentKMer = 0;                                                                       \
+    kmer##type##_t complement = 0;                                                                        \
     /* mask that works even for k=32. */                                                                  \
     kmer##type##_t mask = (((kmer##type##_t) 1) <<  (2 * k - 1));                                         \
     mask |= mask - 1;                                                                                     \
@@ -55,9 +56,13 @@ void ReadKMers(kh_S##variant##_t *kMers, std::string &path, int k, bool compleme
         currentKMer <<= 2;                                                                                \
         currentKMer &= mask;                                                                              \
         currentKMer |= data;                                                                              \
+        complement >>= 2;                                                                                 \
+        complement |= ((kmer##type##_t (3)) ^ data) << ((k - 1) << 1);                                    \
         if(beforeKMerEnd > 0) --beforeKMerEnd;                                                            \
         if (beforeKMerEnd == 0) {                                                                         \
-            insertKMer(kMers, currentKMer, k, complements);                                               \
+            kmer##type##_t canonicalKMer = ((!complements) || currentKMer < complement) ?                 \
+                    currentKMer : complement;                                                             \
+            insertCanonicalKMer(kMers, canonicalKMer);                                                    \
         }                                                                                                 \
     }                                                                                                     \
     if (filestream.is_open()) filestream.close();                                                         \
@@ -80,5 +85,5 @@ void ReadKMersThread##variant(void *arg, long i, int _) {
 
 INIT_PARSER(64, 64S)
 INIT_PARSER(64, 64M)
-INIT_PARSER(128, 128S)
 INIT_PARSER(128, 128M)
+INIT_PARSER(256, 256M)
diff --git a/src/prophasm.h b/src/prophasm.h
index 6f033d6..4847f2b 100644
--- a/src/prophasm.h
+++ b/src/prophasm.h
@@ -7,6 +7,7 @@
 #include <cstdint>
 #include <algorithm>
 #include <fstream>
+#include <stack>
 
 #include "kmers.h"
 #include "khash_utils.h"
@@ -15,27 +16,38 @@
 /// Find the right extension to the provided last k-mer from the kMers by trying to append each of {A, C, G, T}.
 /// Return the extension - that is the d chars extending the simplitig - and the extending kMer.
 template <typename KHT, typename kmer_t>
-std::pair<kmer_t, kmer_t> RightExtension(kmer_t last, KHT *kMers, int k, bool complements) {
+inline uint32_t RightExtension(kmer_t &last, kmer_t &complement, kmer_t &canonical, KHT *kMers, int k, bool complements) {
+    kmer_t k2m1 = (k - 1) << 1;
     for (kmer_t ext = 0; ext < 4; ++ext) {
         kmer_t next = (BitSuffix(last, k - 1) << 2) | ext;
-        if (containsKMer(kMers, next, k, complements)) {
-            return {ext, next};
+        kmer_t nextComplement = ((ext ^ 3) << k2m1) | (complement >> 2);
+        canonical = ((!complements) || next < nextComplement) ? next : nextComplement;
+        if (containsCanonicalKMer(kMers, canonical)) {
+            last = next;
+            complement = nextComplement;
+            return ext;
         }
     }
-    return {-1, -1};
+    return -1;
 }
 
 /// Find the left extension to the provided first k-mer from the kMers by trying to prepend each of {A, C, G, T}.
 /// Return the extension - that is the d chars extending the simplitig - and the extending kMer.
 template <typename KHT, typename kmer_t>
-std::pair<kmer_t, kmer_t> LeftExtension(kmer_t first, KHT *kMers, int k,  bool complements) {
+inline uint32_t LeftExtension(kmer_t &first, kmer_t &complement, kmer_t &canonical, KHT *kMers, int k,  bool complements) {
+    kmer_t k2m1 = (k - 1) << 1;
     for (kmer_t ext = 0; ext < 4; ++ext) {
-        kmer_t next = (ext << ((k - 1) << 1)) | BitPrefix(first, k, k - 1);
-        if (containsKMer(kMers, next, k, complements)) {
-            return {ext, next};
+        kmer_t next = (ext << k2m1) | (first >> 2);
+        kmer_t nextComplement = (BitSuffix(complement, k - 1) << 2) | (ext ^ 3);
+        canonical = ((!complements) || next < nextComplement) ? next : nextComplement;
+        if (complements) canonical = std::min(next, nextComplement);
+        if (containsCanonicalKMer(kMers, canonical)) {
+            first = next;
+            complement = nextComplement;
+            return ext;
         }
     }
-    return {-1, -1};
+    return -1;
 }
 
 /// Find the next simplitig.
@@ -45,39 +57,45 @@ template <typename KHT, typename kmer_t>
 void NextSimplitig(KHT *kMers, kmer_t begin, std::ostream& of,  int k, bool complements, int simplitigID) {
      // Maintain the first and last k-mer in the simplitig.
     kmer_t last = begin, first = begin;
+    kmer_t complement = ReverseComplement(begin, k);
+    kmer_t canonical;
     std::string initialKMer = NumberToKMer(begin, k);
-    std::list<char> simplitig {initialKMer.begin(), initialKMer.end()};
+    std::stack<char> simplitig {};
+    for (int i = k - 1; i >= 0; --i) {
+        simplitig.push(initialKMer[i]);
+    }
     eraseKMer(kMers, last, k, complements);
-    // TODO: print the right simplitig part directly after constructing the left part.
     bool extendToRight = true;
     bool extendToLeft = true;
-    while (extendToRight || extendToLeft) {
-        if (extendToRight) {
-            auto [ext, next] = RightExtension(last, kMers, k, complements);
-            if (ext == kmer_t(-1)) {
-                // No right extension found.
-                extendToRight = false;
-            } else {
-                // Extend the simplitig to the right.
-                eraseKMer(kMers, next, k, complements);
-                simplitig.emplace_back(letters[ext]);
-                last = next;
-            }
+    while (extendToLeft) {
+        uint32_t ext =  LeftExtension(first, complement,canonical, kMers, k, complements);
+        if (ext == uint32_t(-1)) {
+            // No left extension found.
+            extendToLeft = false;
         } else {
-            auto [ext, next] =  LeftExtension(first, kMers, k, complements);
-            if (ext == kmer_t(-1)) {
-                // No left extension found.
-                extendToLeft = false;
-            } else {
-                // Extend the simplitig to the left.
-                eraseKMer(kMers, next, k, complements);
-                simplitig.emplace_front(letters[ext]);
-                first = next;
-            }
+            // Extend the simplitig to the left.
+            eraseCanonicalKMer(kMers, canonical);
+            simplitig.push(letters[ext]);
         }
     }
+    complement = ReverseComplement(begin, k);
     of << ">" << simplitigID << std::endl;
-    of << std::string(simplitig.begin(), simplitig.end()) << std::endl;
+    while (!simplitig.empty()) {
+        of << simplitig.top();
+        simplitig.pop();
+    }
+    while (extendToRight) {
+        uint32_t ext = RightExtension(last, complement, canonical, kMers, k, complements);
+        if (ext == uint32_t(-1)) {
+            // No right extension found.
+            extendToRight = false;
+        } else {
+            // Extend the simplitig to the right.
+            eraseCanonicalKMer(kMers, canonical);
+            of << letters[ext];
+        }
+    }
+    of << std::endl;
 }
 
 
@@ -119,5 +137,5 @@ void ComputeSimplitigsThread##variant(void *arg, long i, int _) {
 
 INIT_PROPHASM(64, 64S)
 INIT_PROPHASM(64, 64M)
-INIT_PROPHASM(128, 128S)
 INIT_PROPHASM(128, 128M)
+INIT_PROPHASM(256, 256M)
diff --git a/src/uint256_t/uint256_t.build b/src/uint256_t/uint256_t.build
new file mode 100644
index 0000000..114299a
--- /dev/null
+++ b/src/uint256_t/uint256_t.build
@@ -0,0 +1,17 @@
+// IMPLEMENTATION BUILD HEADER
+
+// We need uint128_t symbols as plain "extern", neither import nor export
+// because we're linking the 128 and 256 object files into a single library
+// So we can only have one export for symbol in any translation unit
+#define UINT256_T_EXTERN
+typedef __uint128_t uint128_t;
+#undef UINT256_T_EXTERN
+
+#ifndef _UNIT256_T_BUILD
+  #define _UINT256_T_BUILD
+  #include "uint256_t_config.include"
+    const uint128_t uint128_0(0);
+    const uint128_t uint128_1(1);
+  #define UINT256_T_EXTERN _UINT256_T_EXPORT
+#endif
+#include "uint256_t.include"
diff --git a/src/uint256_t/uint256_t.h b/src/uint256_t/uint256_t.h
new file mode 100644
index 0000000..1f3ddae
--- /dev/null
+++ b/src/uint256_t/uint256_t.h
@@ -0,0 +1,495 @@
+#ifndef __LITTLE_ENDIAN__
+#ifndef __BIG_ENDIAN__
+  #define __LITTLE_ENDIAN__ 1
+#endif
+#endif
+#include "uint256_t.build"
+#include <vector>
+#include <cstring>
+
+const uint128_t uint128_64(64);
+const uint128_t uint128_128(128);
+const uint128_t uint128_256(256);
+const uint256_t uint256_0(0);
+const uint256_t uint256_1(1);
+const uint256_t uint256_max(uint128_t(-1), uint128_t(-1));
+
+uint256_t::uint256_t(const bool & b)
+    : uint256_t((uint8_t) b)
+{}
+
+uint256_t & uint256_t::operator=(const bool & rhs) {
+    UPPER = 0;
+    LOWER = rhs;
+    return *this;
+}
+
+uint256_t::operator bool() const{
+    return (bool) (UPPER | LOWER);
+}
+
+uint256_t::operator uint8_t() const{
+    return (uint8_t) LOWER;
+}
+
+uint256_t::operator uint16_t() const{
+    return (uint16_t) LOWER;
+}
+
+uint256_t::operator uint32_t() const{
+    return (uint32_t) LOWER;
+}
+
+uint256_t::operator uint64_t() const{
+    return (uint64_t) LOWER;
+}
+
+uint256_t::operator uint128_t() const{
+    return LOWER;
+}
+
+uint256_t uint256_t::operator&(const uint128_t & rhs) const{
+    return uint256_t(uint128_0, LOWER & rhs);
+}
+
+uint256_t uint256_t::operator&(const uint256_t & rhs) const{
+    return uint256_t(UPPER & rhs.UPPER, LOWER & rhs.LOWER);
+}
+
+uint256_t & uint256_t::operator&=(const uint128_t & rhs){
+    UPPER  = uint128_0;
+    LOWER &= rhs;
+    return *this;
+}
+
+uint256_t & uint256_t::operator&=(const uint256_t & rhs){
+    UPPER &= rhs.UPPER;
+    LOWER &= rhs.LOWER;
+    return *this;
+}
+
+uint256_t uint256_t::operator|(const uint128_t & rhs) const{
+    return uint256_t(UPPER , LOWER | rhs);
+}
+
+uint256_t uint256_t::operator|(const uint256_t & rhs) const{
+    return uint256_t(UPPER | rhs.UPPER, LOWER | rhs.LOWER);
+}
+
+uint256_t & uint256_t::operator|=(const uint128_t & rhs){
+    LOWER |= rhs;
+    return *this;
+}
+
+uint256_t & uint256_t::operator|=(const uint256_t & rhs){
+    UPPER |= rhs.UPPER;
+    LOWER |= rhs.LOWER;
+    return *this;
+}
+
+uint256_t uint256_t::operator^(const uint128_t & rhs) const{
+    return uint256_t(UPPER, LOWER ^ rhs);
+}
+
+uint256_t uint256_t::operator^(const uint256_t & rhs) const{
+    return uint256_t(UPPER ^ rhs.UPPER, LOWER ^ rhs.LOWER);
+}
+
+uint256_t & uint256_t::operator^=(const uint128_t & rhs){
+    LOWER ^= rhs;
+    return *this;
+}
+
+uint256_t & uint256_t::operator^=(const uint256_t & rhs){
+    UPPER ^= rhs.UPPER;
+    LOWER ^= rhs.LOWER;
+    return *this;
+}
+
+uint256_t uint256_t::operator~() const{
+    return uint256_t(~UPPER, ~LOWER);
+}
+
+uint256_t uint256_t::operator<<(const uint128_t & rhs) const{
+    return *this << uint256_t(rhs);
+}
+
+uint256_t uint256_t::operator<<(const uint256_t & rhs) const{
+    const uint128_t shift = rhs.LOWER;
+    if (((bool) rhs.UPPER) || (shift >= uint128_256)){
+        return uint256_0;
+    }
+    else if (shift == uint128_128){
+        return uint256_t(LOWER, uint128_0);
+    }
+    else if (shift == uint128_0){
+        return *this;
+    }
+    else if (shift < uint128_128){
+        return uint256_t((UPPER << shift) + (LOWER >> (uint128_128 - shift)), LOWER << shift);
+    }
+    else if ((uint128_256 > shift) && (shift > uint128_128)){
+        return uint256_t(LOWER << (shift - uint128_128), uint128_0);
+    }
+    else{
+        return uint256_0;
+    }
+}
+
+uint256_t & uint256_t::operator<<=(const uint128_t & shift){
+    return *this <<= uint256_t(shift);
+}
+
+uint256_t & uint256_t::operator<<=(const uint256_t & shift){
+    *this = *this << shift;
+    return *this;
+}
+
+uint256_t uint256_t::operator>>(const uint128_t & rhs) const{
+    return *this >> uint256_t(rhs);
+}
+
+uint256_t uint256_t::operator>>(const uint256_t & rhs) const{
+    const uint128_t shift = rhs.LOWER;
+    if (((bool) rhs.UPPER) | (shift >= uint128_256)){
+        return uint256_0;
+    }
+    else if (shift == uint128_128){
+        return uint256_t(UPPER);
+    }
+    else if (shift == uint128_0){
+        return *this;
+    }
+    else if (shift < uint128_128){
+        return uint256_t(UPPER >> shift, (UPPER << (uint128_128 - shift)) + (LOWER >> shift));
+    }
+    else if ((uint128_256 > shift) && (shift > uint128_128)){
+        return uint256_t(UPPER >> (shift - uint128_128));
+    }
+    else{
+        return uint256_0;
+    }
+}
+
+uint256_t & uint256_t::operator>>=(const uint128_t & shift){
+    return *this >>= uint256_t(shift);
+}
+
+uint256_t & uint256_t::operator>>=(const uint256_t & shift){
+    *this = *this >> shift;
+    return *this;
+}
+
+bool uint256_t::operator!() const{
+    return ! (bool) *this;
+}
+
+bool uint256_t::operator&&(const uint128_t & rhs) const{
+    return (*this && uint256_t(rhs));
+}
+
+bool uint256_t::operator&&(const uint256_t & rhs) const{
+    return ((bool) *this && (bool) rhs);
+}
+
+bool uint256_t::operator||(const uint128_t & rhs) const{
+    return (*this || uint256_t(rhs));
+}
+
+bool uint256_t::operator||(const uint256_t & rhs) const{
+    return ((bool) *this || (bool) rhs);
+}
+
+bool uint256_t::operator==(const uint128_t & rhs) const{
+    return (*this == uint256_t(rhs));
+}
+
+bool uint256_t::operator==(const uint256_t & rhs) const{
+    return ((UPPER == rhs.UPPER) && (LOWER == rhs.LOWER));
+}
+
+bool uint256_t::operator!=(const uint128_t & rhs) const{
+    return (*this != uint256_t(rhs));
+}
+
+bool uint256_t::operator!=(const uint256_t & rhs) const{
+    return ((UPPER != rhs.UPPER) | (LOWER != rhs.LOWER));
+}
+
+bool uint256_t::operator>(const uint128_t & rhs) const{
+    return (*this > uint256_t(rhs));
+}
+
+bool uint256_t::operator>(const uint256_t & rhs) const{
+    if (UPPER == rhs.UPPER){
+        return (LOWER > rhs.LOWER);
+    }
+    if (UPPER > rhs.UPPER){
+        return true;
+    }
+    return false;
+}
+
+bool uint256_t::operator<(const uint128_t & rhs) const{
+    return (*this < uint256_t(rhs));
+}
+
+bool uint256_t::operator<(const uint256_t & rhs) const{
+    if (UPPER == rhs.UPPER){
+        return (LOWER < rhs.LOWER);
+    }
+    if (UPPER < rhs.UPPER){
+        return true;
+    }
+    return false;
+}
+
+bool uint256_t::operator>=(const uint128_t & rhs) const{
+    return (*this >= uint256_t(rhs));
+}
+
+bool uint256_t::operator>=(const uint256_t & rhs) const{
+    return ((*this > rhs) | (*this == rhs));
+}
+
+bool uint256_t::operator<=(const uint128_t & rhs) const{
+    return (*this <= uint256_t(rhs));
+}
+
+bool uint256_t::operator<=(const uint256_t & rhs) const{
+    return ((*this < rhs) | (*this == rhs));
+}
+
+uint256_t uint256_t::operator+(const uint128_t & rhs) const{
+    return *this + uint256_t(rhs);
+}
+
+uint256_t uint256_t::operator+(const uint256_t & rhs) const{
+    return uint256_t(UPPER + rhs.UPPER + (((LOWER + rhs.LOWER) < LOWER)?uint128_1:uint128_0), LOWER + rhs.LOWER);
+}
+
+uint256_t & uint256_t::operator+=(const uint128_t & rhs){
+    return *this += uint256_t(rhs);
+}
+
+uint256_t & uint256_t::operator+=(const uint256_t & rhs){
+    UPPER = rhs.UPPER + UPPER + ((LOWER + rhs.LOWER) < LOWER);
+    LOWER = LOWER + rhs.LOWER;
+    return *this;
+}
+
+uint256_t uint256_t::operator-(const uint128_t & rhs) const{
+    return *this - uint256_t(rhs);
+}
+
+uint256_t uint256_t::operator-(const uint256_t & rhs) const{
+    return uint256_t(UPPER - rhs.UPPER - ((LOWER - rhs.LOWER) > LOWER), LOWER - rhs.LOWER);
+}
+
+uint256_t & uint256_t::operator-=(const uint128_t & rhs){
+    return *this -= uint256_t(rhs);
+}
+
+uint256_t & uint256_t::operator-=(const uint256_t & rhs){
+    *this = *this - rhs;
+    return *this;
+}
+
+uint256_t & uint256_t::operator++(){
+    *this += uint256_1;
+    return *this;
+}
+
+uint256_t uint256_t::operator++(int){
+    uint256_t temp(*this);
+    ++*this;
+    return temp;
+}
+
+uint256_t & uint256_t::operator--(){
+    *this -= uint256_1;
+    return *this;
+}
+
+uint256_t uint256_t::operator--(int){
+    uint256_t temp(*this);
+    --*this;
+    return temp;
+}
+
+uint256_t uint256_t::operator+() const{
+    return *this;
+}
+
+uint256_t uint256_t::operator-() const{
+    return ~*this + uint256_1;
+}
+
+const uint128_t & uint256_t::upper() const {
+    return UPPER;
+}
+
+const uint128_t & uint256_t::lower() const {
+    return LOWER;
+}
+
+uint256_t operator&(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs & lhs;
+}
+
+uint128_t & operator&=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (rhs & lhs).lower();
+    return lhs;
+}
+
+uint256_t operator|(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs | lhs;
+}
+
+uint128_t & operator|=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (rhs | lhs).lower();
+    return lhs;
+}
+
+uint256_t operator^(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs ^ lhs;
+}
+
+uint128_t & operator^=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (rhs ^ lhs).lower();
+    return lhs;
+}
+
+uint256_t operator<<(const bool & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const uint8_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const uint16_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const uint32_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const uint64_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const uint128_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const int8_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const int16_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const int32_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint256_t operator<<(const int64_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) << rhs;
+}
+
+uint128_t & operator<<=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (uint256_t(lhs) << rhs).lower();
+    return lhs;
+}
+
+uint256_t operator>>(const bool & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const uint8_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const uint16_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const uint32_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const uint64_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const uint128_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const int8_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const int16_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const int32_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint256_t operator>>(const int64_t & lhs, const uint256_t & rhs){
+    return uint256_t(lhs) >> rhs;
+}
+
+uint128_t & operator>>=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (uint256_t(lhs) >> rhs).lower();
+    return lhs;
+}
+
+// Comparison Operators
+bool operator==(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs == lhs;
+}
+
+bool operator!=(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs != lhs;
+}
+
+bool operator>(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs < lhs;
+}
+
+bool operator<(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs > lhs;
+}
+
+bool operator>=(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs <= lhs;
+}
+
+bool operator<=(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs >= lhs;
+}
+
+// Arithmetic Operators
+uint256_t operator+(const uint128_t & lhs, const uint256_t & rhs){
+    return rhs + lhs;
+}
+
+uint128_t & operator+=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (rhs + lhs).lower();
+    return lhs;
+}
+
+uint256_t operator-(const uint128_t & lhs, const uint256_t & rhs){
+    return -(rhs - lhs);
+}
+
+uint128_t & operator-=(uint128_t & lhs, const uint256_t & rhs){
+    lhs = (-(rhs - lhs)).lower();
+    return lhs;
+}
diff --git a/src/uint256_t/uint256_t.include b/src/uint256_t/uint256_t.include
new file mode 100644
index 0000000..1e719a6
--- /dev/null
+++ b/src/uint256_t/uint256_t.include
@@ -0,0 +1,537 @@
+/*
+uint256_t.h
+An unsigned 256 bit integer library for C++
+
+Copyright (c) 2013 - 2017 Jason Lee @ calccrypto at gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+With much help from Auston Sterling
+
+Thanks to François Dessenne for convincing me
+to do a general rewrite of this class.
+
+
+Ondřej Sladký: removed parts of this file as they were not needed and were
+not compatible with __uint128_t.
+*/
+
+#ifndef __UINT256_T__
+#define __UINT256_T__
+
+#include <cstdint>
+#include <ostream>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+class UINT256_T_EXTERN uint256_t;
+
+// Give uint256_t type traits
+namespace std {  // This is probably not a good idea
+    template <> struct is_arithmetic <uint256_t> : std::true_type {};
+    template <> struct is_integral   <uint256_t> : std::true_type {};
+    template <> struct is_unsigned   <uint256_t> : std::true_type {};
+}
+
+class uint256_t{
+    private:
+#ifdef __BIG_ENDIAN__
+        uint128_t UPPER, LOWER;
+#endif
+#ifdef __LITTLE_ENDIAN__
+        uint128_t LOWER, UPPER;
+#endif
+
+    public:
+        // Constructors
+        uint256_t() = default;
+        uint256_t(const uint256_t & rhs) = default;
+        uint256_t(uint256_t && rhs) = default;
+        uint256_t(const std::string & s);
+        uint256_t(const char *val);
+        uint256_t(const std::string & s, uint8_t base);
+        uint256_t(const char *val, uint8_t base);
+        uint256_t(const bool & b);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t(const T & rhs)
+#ifdef __BIG_ENDIAN__
+            : UPPER(uint128_0), LOWER(rhs)
+#endif
+#ifdef __LITTLE_ENDIAN__
+            : LOWER(rhs), UPPER(uint128_0)
+#endif
+        {
+            if (std::is_signed<T>::value) {
+                if (rhs < 0) {
+                    UPPER = uint128_t(-1);
+                }
+            }
+        }
+
+        template <typename S, typename T, typename = typename std::enable_if <std::is_integral<S>::value && std::is_integral<T>::value, void>::type>
+        uint256_t(const S & upper_rhs, const T & lower_rhs)
+#ifdef __BIG_ENDIAN__
+            : UPPER(upper_rhs), LOWER(lower_rhs)
+#endif
+#ifdef __LITTLE_ENDIAN__
+            : LOWER(lower_rhs), UPPER(upper_rhs)
+#endif
+        {}
+
+        uint256_t(const uint128_t & upper_rhs, const uint128_t & lower_rhs)
+#ifdef __BIG_ENDIAN__
+            : UPPER(upper_rhs), LOWER(lower_rhs)
+#endif
+#ifdef __LITTLE_ENDIAN__
+            : LOWER(lower_rhs), UPPER(upper_rhs)
+#endif
+        {}
+        uint256_t(const uint128_t & lower_rhs)
+#ifdef __BIG_ENDIAN__
+            : UPPER(uint128_0), LOWER(lower_rhs)
+#endif
+#ifdef __LITTLE_ENDIAN__
+            : LOWER(lower_rhs), UPPER(uint128_0)
+#endif
+        {}
+
+       template <typename R, typename S, typename T, typename U,
+                typename = typename std::enable_if<std::is_integral<R>::value &&
+                std::is_integral<S>::value &&
+                std::is_integral<T>::value &&
+                std::is_integral<U>::value, void>::type>
+        uint256_t(const R & upper_lhs, const S & lower_lhs, const T & upper_rhs, const U & lower_rhs)
+#ifdef __BIG_ENDIAN__
+            : UPPER(upper_lhs, lower_lhs), LOWER(upper_rhs, lower_rhs)
+#endif
+#ifdef __LITTLE_ENDIAN__
+            : LOWER(upper_rhs, lower_rhs), UPPER(upper_lhs, lower_lhs)
+#endif
+        {}
+
+        // Assignment Operator
+        uint256_t & operator=(const uint256_t & rhs) = default;
+        uint256_t & operator=(uint256_t && rhs) = default;
+
+        template <typename T, typename = typename std::enable_if <std::is_integral<T>::value, T>::type>
+        uint256_t & operator=(const T & rhs){
+            UPPER = uint128_0;
+
+            if (std::is_signed<T>::value) {
+                if (rhs < 0) {
+                    UPPER = uint128_t(-1);
+                }
+            }
+
+            LOWER = rhs;
+            return *this;
+        }
+
+        uint256_t & operator=(const bool & rhs);
+
+        // Typecast Operators
+        operator bool      () const;
+        operator uint8_t   () const;
+        operator uint16_t  () const;
+        operator uint32_t  () const;
+        operator uint64_t  () const;
+        operator uint128_t () const;
+
+        // Bitwise Operators
+        uint256_t operator&(const uint128_t & rhs) const;
+        uint256_t operator&(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator&(const T & rhs) const{
+            return uint256_t(uint128_0, LOWER & (uint128_t) rhs);
+        }
+
+        uint256_t & operator&=(const uint128_t & rhs);
+        uint256_t & operator&=(const uint256_t & rhs);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator&=(const T & rhs){
+            UPPER = uint128_0;
+            LOWER &= rhs;
+            return *this;
+        }
+
+        uint256_t operator|(const uint128_t & rhs) const;
+        uint256_t operator|(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator|(const T & rhs) const{
+            return uint256_t(UPPER, LOWER | uint128_t(rhs));
+        }
+
+        uint256_t & operator|=(const uint128_t & rhs);
+        uint256_t & operator|=(const uint256_t & rhs);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator|=(const T & rhs){
+            LOWER |= (uint128_t) rhs;
+            return *this;
+        }
+
+        uint256_t operator^(const uint128_t & rhs) const;
+        uint256_t operator^(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator^(const T & rhs) const{
+            return uint256_t(UPPER, LOWER ^ (uint128_t) rhs);
+        }
+
+        uint256_t & operator^=(const uint128_t & rhs);
+        uint256_t & operator^=(const uint256_t & rhs);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator^=(const T & rhs){
+            LOWER ^= (uint128_t) rhs;
+            return *this;
+        }
+
+        uint256_t operator~() const;
+
+        // Bit Shift Operators
+        uint256_t operator<<(const uint128_t & shift) const;
+        uint256_t operator<<(const uint256_t & shift) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator<<(const T & rhs) const{
+            return *this << uint256_t(rhs);
+        }
+
+        uint256_t & operator<<=(const uint128_t & shift);
+        uint256_t & operator<<=(const uint256_t & shift);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator<<=(const T & rhs){
+            *this = *this << uint256_t(rhs);
+            return *this;
+        }
+
+        uint256_t operator>>(const uint128_t & shift) const;
+        uint256_t operator>>(const uint256_t & shift) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator>>(const T & rhs) const{
+            return *this >> uint256_t(rhs);
+        }
+
+        uint256_t & operator>>=(const uint128_t & shift);
+        uint256_t & operator>>=(const uint256_t & shift);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator>>=(const T & rhs){
+            *this = *this >> uint256_t(rhs);
+            return *this;
+        }
+
+        // Logical Operators
+        bool operator!() const;
+
+        bool operator&&(const uint128_t & rhs) const;
+        bool operator&&(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator&&(const T & rhs) const{
+            return ((bool) *this && rhs);
+        }
+
+        bool operator||(const uint128_t & rhs) const;
+        bool operator||(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator||(const T & rhs) const{
+            return ((bool) *this || rhs);
+        }
+
+        // Comparison Operators
+        bool operator==(const uint128_t & rhs) const;
+        bool operator==(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator==(const T & rhs) const{
+            return (!UPPER && (LOWER == uint128_t(rhs)));
+        }
+
+        bool operator!=(const uint128_t & rhs) const;
+        bool operator!=(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator!=(const T & rhs) const{
+            return ((bool) UPPER | (LOWER != uint128_t(rhs)));
+        }
+
+        bool operator>(const uint128_t & rhs) const;
+        bool operator>(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator>(const T & rhs) const{
+            return ((bool) UPPER | (LOWER > uint128_t(rhs)));
+        }
+
+        bool operator<(const uint128_t & rhs) const;
+        bool operator<(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator<(const T & rhs) const{
+            return (!UPPER)?(LOWER < uint128_t(rhs)):false;
+        }
+
+        bool operator>=(const uint128_t & rhs) const;
+        bool operator>=(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator>=(const T & rhs) const{
+            return ((*this > rhs) | (*this == rhs));
+        }
+
+        bool operator<=(const uint128_t & rhs) const;
+        bool operator<=(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        bool operator<=(const T & rhs) const{
+            return ((*this < rhs) | (*this == rhs));
+        }
+
+        // Arithmetic Operators
+        uint256_t operator+(const uint128_t & rhs) const;
+        uint256_t operator+(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator+(const T & rhs) const{
+            return uint256_t(UPPER + ((LOWER + (uint128_t) rhs) < LOWER), LOWER + (uint128_t) rhs);
+        }
+
+        uint256_t & operator+=(const uint128_t & rhs);
+        uint256_t & operator+=(const uint256_t & rhs);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator+=(const T & rhs){
+            return *this += uint256_t(rhs);
+        }
+
+        uint256_t operator-(const uint128_t & rhs) const;
+        uint256_t operator-(const uint256_t & rhs) const;
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t operator-(const T & rhs) const{
+            return uint256_t(UPPER - ((LOWER - rhs) > LOWER), LOWER - rhs);
+        }
+
+        uint256_t & operator-=(const uint128_t & rhs);
+        uint256_t & operator-=(const uint256_t & rhs);
+
+        template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+        uint256_t & operator-=(const T & rhs){
+            return *this = *this - uint256_t(rhs);
+        }
+
+        // Increment Operators
+        uint256_t & operator++();
+        uint256_t operator++(int);
+
+        // Decrement Operators
+        uint256_t & operator--();
+        uint256_t operator--(int);
+
+        // Nothing done since promotion doesn't work here
+        uint256_t operator+() const;
+
+        // two's complement
+        uint256_t operator-() const;
+
+        // Get private values
+        const uint128_t & upper() const;
+        const uint128_t & lower() const;
+
+        // Get bitsize of value
+        uint16_t bits() const;
+
+        // Get string representation of value
+        std::string str(uint8_t base = 10, const unsigned int & len = 0) const;
+};
+
+// useful values
+UINT256_T_EXTERN extern const uint128_t uint128_64;
+UINT256_T_EXTERN extern const uint128_t uint128_128;
+UINT256_T_EXTERN extern const uint128_t uint128_256;
+UINT256_T_EXTERN extern const uint256_t uint256_0;
+UINT256_T_EXTERN extern const uint256_t uint256_1;
+UINT256_T_EXTERN extern const uint256_t uint256_max;
+
+// Bitwise Operators
+UINT256_T_EXTERN uint256_t operator&(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+ uint256_t operator&(const T & lhs, const uint256_t & rhs){
+    return rhs & lhs;
+}
+
+UINT256_T_EXTERN uint128_t & operator&=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator&=(T & lhs, const uint256_t & rhs){
+    return lhs = static_cast <T> (rhs & lhs);
+}
+
+UINT256_T_EXTERN uint256_t operator|(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+uint256_t operator|(const T & lhs, const uint256_t & rhs){
+    return rhs | lhs;
+}
+
+UINT256_T_EXTERN uint128_t & operator|=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator|=(T & lhs, const uint256_t & rhs){
+    return lhs = static_cast <T> (rhs | lhs);
+}
+
+UINT256_T_EXTERN uint256_t operator^(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+uint256_t operator^(const T & lhs, const uint256_t & rhs){
+    return rhs ^ lhs;
+}
+
+uint128_t & operator^=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator^=(T & lhs, const uint256_t & rhs){
+    return lhs = static_cast <T> (rhs ^ lhs);
+}
+
+// Bitshift operators
+UINT256_T_EXTERN uint256_t operator<<(const bool      & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const uint8_t   & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const uint16_t  & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const uint32_t  & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const uint64_t  & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const uint128_t & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const int8_t    & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const int16_t   & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const int32_t   & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator<<(const int64_t   & lhs, const uint256_t & rhs);
+
+UINT256_T_EXTERN uint128_t & operator<<=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator<<=(T & lhs, const uint256_t & rhs){
+    lhs = static_cast <T> (uint256_t(lhs) << rhs);
+    return lhs;
+}
+
+UINT256_T_EXTERN uint256_t operator>>(const bool      & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const uint8_t   & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const uint16_t  & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const uint32_t  & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const uint64_t  & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const uint128_t & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const int8_t    & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const int16_t   & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const int32_t   & lhs, const uint256_t & rhs);
+UINT256_T_EXTERN uint256_t operator>>(const int64_t   & lhs, const uint256_t & rhs);
+
+UINT256_T_EXTERN uint128_t & operator>>=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator>>=(T & lhs, const uint256_t & rhs){
+    return lhs = static_cast <T> (uint256_t(lhs) >> rhs);
+}
+
+// Comparison Operators
+UINT256_T_EXTERN bool operator==(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+bool operator==(const T & lhs, const uint256_t & rhs){
+    return (!rhs.upper() && ((uint64_t) lhs == rhs.lower()));
+}
+
+UINT256_T_EXTERN bool operator!=(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+bool operator!=(const T & lhs, const uint256_t & rhs){
+    return (rhs.upper() | ((uint64_t) lhs != rhs.lower()));
+}
+
+UINT256_T_EXTERN bool operator>(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+bool operator>(const T & lhs, const uint256_t & rhs){
+    return rhs.upper()?false:((uint128_t) lhs > rhs.lower());
+}
+
+UINT256_T_EXTERN bool operator<(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+bool operator<(const T & lhs, const uint256_t & rhs){
+    return rhs.upper()?true:((uint128_t) lhs < rhs.lower());
+}
+
+UINT256_T_EXTERN bool operator>=(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+bool operator>=(const T & lhs, const uint256_t & rhs){
+    return rhs.upper()?false:((uint128_t) lhs >= rhs.lower());
+}
+
+UINT256_T_EXTERN bool operator<=(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+bool operator<=(const T & lhs, const uint256_t & rhs){
+    return rhs.upper()?true:((uint128_t) lhs <= rhs.lower());
+}
+
+// Arithmetic Operators
+UINT256_T_EXTERN uint256_t operator+(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+uint256_t operator+(const T & lhs, const uint256_t & rhs){
+    return rhs + lhs;
+}
+
+UINT256_T_EXTERN uint128_t & operator+=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator+=(T & lhs, const uint256_t & rhs){
+    lhs = static_cast <T> (rhs + lhs);
+    return lhs;
+}
+
+UINT256_T_EXTERN uint256_t operator-(const uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+uint256_t operator-(const T & lhs, const uint256_t & rhs){
+    return -(rhs - lhs);
+}
+
+UINT256_T_EXTERN uint128_t & operator-=(uint128_t & lhs, const uint256_t & rhs);
+
+template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
+T & operator-=(T & lhs, const uint256_t & rhs){
+    return lhs = static_cast <T> (-(rhs - lhs));
+}
+
+#endif
diff --git a/src/uint256_t/uint256_t_config.include b/src/uint256_t/uint256_t_config.include
new file mode 100644
index 0000000..e83db51
--- /dev/null
+++ b/src/uint256_t/uint256_t_config.include
@@ -0,0 +1,19 @@
+#ifndef _UINT256_T_CONFIG_
+  #define _UINT256_T_CONFIG_
+  #if defined(_MSC_VER)
+    #if defined(_DLL)
+      #define _UINT256_T_EXPORT __declspec(dllexport)
+      #define _UINT256_T_IMPORT __declspec(dllimport)
+    #else
+      #define _UINT256_T_EXPORT
+      #define _UINT256_T_IMPORT
+    #endif
+  #else
+    // All modules on Unix are compiled with -fvisibility=hidden
+    // All API symbols get visibility default
+    // whether or not we're static linking or dynamic linking (with -fPIC)
+    #define _UINT256_T_EXPORT __attribute__((visibility("default"))) 
+    #define _UINT256_T_IMPORT __attribute__((visibility("default"))) 
+  #endif
+#endif
+
diff --git a/tests/khash_utils_unittest.h b/tests/khash_utils_unittest.h
index 49d9741..f63f0b6 100644
--- a/tests/khash_utils_unittest.h
+++ b/tests/khash_utils_unittest.h
@@ -31,17 +31,15 @@ namespace {
     TEST(KHASH_UTILS, Intersection) {
         struct TestCase {
             std::vector<std::vector<kmer_t>> kMerSets;
-            int k;
-            bool complements;
             std::vector<kmer_t> wantResult;
         };
         std::vector<TestCase> tests = {
                 // {{TCC, CTA, ACT, CCT}, {TCC, ACT, CCT}}
-                {{{0b110101, 0b011100, 0b000111, 0b010111}, {0b110101, 0b000111, 0b010111}}, 3, false, {0b110101, 0b000111, 0b010111}},
+                {{{0b110101, 0b011100, 0b000111, 0b010111}, {0b110101, 0b000111, 0b010111}}, {0b110101, 0b000111, 0b010111}},
                 // {{TCC, CTA, ACT, CCT}, {TCC, ACT, CCT}, {TCC, CTA, ACT, TCT}}
-                {{{0b110101, 0b011100, 0b000111, 0b010111}, {0b110101, 0b000111, 0b010111}, {0b110101, 0b011100, 0b000111, 0b110111}}, 3, false, {0b110101, 0b000111}},
+                {{{0b110101, 0b011100, 0b000111, 0b010111}, {0b110101, 0b000111, 0b010111}, {0b110101, 0b011100, 0b000111, 0b110111}}, {0b110101, 0b000111}},
                 // {{CC}, {GG}}
-                {{{0b0101}, {0b0101}}, 2, true, {0b0101}},
+                {{{0b0101}, {0b0101}}, {0b0101}},
         };
 
         for (auto t : tests) {
@@ -53,7 +51,7 @@ namespace {
             }
 
             kh_S64M_t * gotResult = kh_init_S64M();
-            getIntersection(gotResult, input, t.k, t.complements);
+            getIntersection(gotResult, input);
             auto gotResultVec = kMersToVec(gotResult);
             sort(t.wantResult.begin(), t.wantResult.end());
             sort(gotResultVec.begin(), gotResultVec.end());
diff --git a/tests/kmers_unittest.h b/tests/kmers_unittest.h
index b71d776..30a0efe 100644
--- a/tests/kmers_unittest.h
+++ b/tests/kmers_unittest.h
@@ -106,6 +106,50 @@ namespace {
         }
     }
 
+    TEST(KMers, ReverseComplement128) {
+        struct TestCase {
+            kmer128_t input;
+            int k;
+            kmer128_t wantResult;
+        };
+        std::vector<TestCase> tests = {
+                {0b1001LL, 2, 0b1001LL},
+                {0b101111LL, 3, 0b000001LL},
+                {0b11LL, 1, 0b00LL},
+                {0b11111111'01111111'11111111'11111111'11111111'11111111'11111111'11111110LL, 32, 0b010000'00000000'00000000'00000000'00000000'00000000'00000000'1000000000LL },
+                {(kmer128_t (0b11111111'01111111'11111111'11111111'11111111'11111111'11111111'11111110LL) << 64) + kmer128_t (0b10111111'01111111'11111111'11111111'11111111'11111111'11111111'11111110LL) ,
+                 64, (kmer128_t (0b010000'00000000'00000000'00000000'00000000'00000000'00000000'1000000001LL)<<64 ) + kmer128_t (0b010000'00000000'00000000'00000000'00000000'00000000'00000000'1000000000LL) },
+        };
+
+        for (auto t: tests) {
+            kmer128_t gotResult = ReverseComplement(t.input, t.k);
+
+            EXPECT_EQ(t.wantResult, gotResult);
+        }
+    }
+
+    TEST(KMers, ReverseComplement256) {
+        struct TestCase {
+            kmer256_t input;
+            int k;
+            kmer256_t wantResult;
+        };
+        std::vector<TestCase> tests = {
+                {0b1001LL, 2, 0b1001LL},
+                {0b101111LL, 3, 0b000001LL},
+                {0b11LL, 1, 0b00LL},
+                {0b11111111'01111111'11111111'11111111'11111111'11111111'11111111'11111110LL, 32, 0b010000'00000000'00000000'00000000'00000000'00000000'00000000'1000000000LL },
+                {(kmer128_t (0b11111111'01111111'11111111'11111111'11111111'11111111'11111111'11111110LL) << 64) + kmer128_t (0b10111111'01111111'11111111'11111111'11111111'11111111'11111111'11111110LL) ,
+                        64, (kmer128_t (0b010000'00000000'00000000'00000000'00000000'00000000'00000000'1000000001LL)<<64 ) + kmer128_t (0b010000'00000000'00000000'00000000'00000000'00000000'00000000'1000000000LL) },
+        };
+
+        for (auto t: tests) {
+        kmer256_t gotResult = ReverseComplement(t.input, t.k);
+
+        EXPECT_EQ(t.wantResult, gotResult);
+        }
+    }
+
     TEST(KMers, CanonicalKMer) {
         struct TestCase {
             kmer_t input;
diff --git a/tests/prophasm_unittest.h b/tests/prophasm_unittest.h
index f73a2c9..ca541a9 100644
--- a/tests/prophasm_unittest.h
+++ b/tests/prophasm_unittest.h
@@ -7,17 +7,19 @@ namespace {
     TEST(Prophasm, RightExtension) {
         struct TestCase {
             kmer_t last;
+            kmer_t complement; // Irrelevant if complements is set to false.
             std::vector<kmer_t> kMers;
             int k;
             bool complements;
-            kmer_t wantExt;
-            kmer_t  wantNext;
+            uint32_t wantExt;
+            kmer_t wantNext;
+            kmer_t wantComplement;
         };
         std::vector<TestCase> tests = {
                 // ACT; {TCC, CTA, ACT, CCT}; A; CTA
-                {0b000111, {0b110101, 0b011100, 0b000111, 0b010111}, 3, false, 0b00, 0b011100},
+                {0b000111, 0b001011, {0b110101, 0b011100, 0b000111, 0b010111}, 3, false, 0b00, 0b011100, 0b110010},
                 // ACT; {TCC, ACT, CCT}
-                {0b000111, {0b110101, 0b000111, 0b010111}, 3, false,  kmer_t(-1), kmer_t(-1)},
+                {0b000111, 0b001011, {0b110101, 0b000111, 0b010111}, 3, false,  uint32_t(-1), 0b000111, 0b001011},
         };
 
         for (auto t: tests) {
@@ -25,29 +27,31 @@ namespace {
             int ret;
             for (auto &&kMer : t.kMers) kh_put_S64M(kMers, kMer, &ret);
 
-            auto got = RightExtension(t.last, kMers, t.k, t.complements);
-            auto gotExt = got.first;
-            auto gotNext = got.second;
+            kmer_t _;
+            auto got = RightExtension(t.last, t.complement, _, kMers, t.k, t.complements);
 
-            EXPECT_EQ(t.wantNext, gotNext);
-            EXPECT_EQ(t.wantExt, gotExt);
+            EXPECT_EQ(t.wantNext, t.last);
+            EXPECT_EQ(t.wantComplement, t.complement);
+            EXPECT_EQ(t.wantExt, got);
         }
     }
 
     TEST(Prophasm, LeftExtension) {
         struct TestCase {
             kmer_t first;
+            kmer_t complement; // Irrelevant if complements is set to false.
             std::vector<kmer_t> kMers;
             int k;
             bool complements;
-            kmer_t wantExt;
-            kmer_t  wantNext;
+            uint32_t wantExt;
+            kmer_t wantNext;
+            kmer_t wantComplement;
         };
         std::vector<TestCase> tests = {
                 // ACT; {TCC, ACT, CCT}
-                {0b000111, {0b110101, 0b000111, 0b010111}, 3, false,   kmer_t(-1), kmer_t(-1)},
+                {0b000111, 0b001011, {0b110101, 0b000111, 0b010111}, 3, false,  uint32_t(-1), 0b000111, 0b001011},
                 // TAC; {TCC, CTA, ACT, CCT}; C; CTA
-                {0b110001, {0b110101, 0b011100, 0b000111, 0b010111}, 3, false, 0b01, 0b011100},
+                {0b110001, 0b101100, {0b110101, 0b011100, 0b000111, 0b010111}, 3, false, 0b01, 0b011100, 0b110010},
         };
 
         for (auto t: tests) {
@@ -55,11 +59,11 @@ namespace {
             int ret;
             for (auto &&kMer : t.kMers) kh_put_S64M(kMers, kMer, &ret);
 
-            auto got = LeftExtension(t.first, kMers, t.k, t.complements);
-            auto gotExt = got.first;
-            auto gotNext = got.second;
-            EXPECT_EQ(t.wantNext, gotNext);
-            EXPECT_EQ(t.wantExt, gotExt);
+            kmer_t _;
+            auto got = LeftExtension(t.first, t.complement, _, kMers, t.k, t.complements);
+            EXPECT_EQ(t.wantNext, t.first);
+            EXPECT_EQ(t.wantComplement, t.complement);
+            EXPECT_EQ(t.wantExt, got);
         }
     }