diff --git a/stint.nim b/stint.nim
index 900d2b1..f13f275 100644
--- a/stint.nim
+++ b/stint.nim
@@ -7,8 +7,8 @@
 #
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
-import stint/[uint_public, int_public, io, modular_arithmetic, literals_stint]
-export uint_public, int_public, io, modular_arithmetic, literals_stint
+import stint/[bitops2, endians2, intops, io, modular_arithmetic, literals_stint]
+export bitops2, endians2, intops, io, modular_arithmetic, literals_stint
 
 type
   Int128* = Stint[128]
diff --git a/stint/bitops2.nim b/stint/bitops2.nim
new file mode 100644
index 0000000..9bad7c8
--- /dev/null
+++ b/stint/bitops2.nim
@@ -0,0 +1,16 @@
+# Stint
+# Copyright 2018 Status Research & Development GmbH
+# Licensed under either of
+#
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+#
+# at your option. This file may not be copied, modified, or distributed except according to those terms.
+
+import ./private/[bitops2_priv, datatypes]
+
+func countOnes*(x: StUint): int {.inline.} = countOnes(x.data)
+func parity*(x: StUint): int {.inline.} = parity(x.data)
+func firstOne*(x: StUint): int {.inline.} = firstOne(x.data)
+func leadingZeros*(x: StUint): int {.inline.} = leadingZeros(x.data)
+func trailingZeros*(x: StUint): int {.inline.} = trailingZeros(x.data)
diff --git a/stint/endians2.nim b/stint/endians2.nim
new file mode 100644
index 0000000..e13f87e
--- /dev/null
+++ b/stint/endians2.nim
@@ -0,0 +1,105 @@
+# Stint
+# Copyright 2018 Status Research & Development GmbH
+# Licensed under either of
+#
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+#
+# at your option. This file may not be copied, modified, or distributed except according to those terms.
+
+import private/[bitops2_priv, endians2_priv, datatypes]
+
+import stew/endians2
+export endians2
+
+func swapBytes*(x: StUint): StUint {.inline.} = StUint(data: swapBytes(x.data))
+
+func toBytes*[bits: static int](x: StUint[bits], endian: Endianness = system.cpuEndian):
+    array[bits div 8, byte] {.inline.} =
+  toBytes(x.data, endian)
+
+func toBytesLE*[bits: static int](x: StUint[bits]):
+    array[bits div 8, byte] {.inline.} =
+  toBytes(x, littleEndian)
+
+func toBytesBE*[bits: static int](x: StUint[bits]):
+    array[bits div 8, byte] {.inline.} =
+  toBytes(x, bigEndian)
+
+func fromBytes*[bits: static int](
+    T: typedesc[StUint[bits]],
+    x: array[bits div 8, byte],
+    endian: Endianness = system.cpuEndian): T {.inline, noinit.} =
+  # TODO compile-time version
+  copyMem(addr result, unsafeAddr x[0], bits div 8)
+
+  if endian != system.cpuEndian:
+    result = swapBytes(result)
+
+func fromBytes*[bits: static int](
+    T: typedesc[StUint[bits]],
+    x: openArray[byte],
+    endian: Endianness = system.cpuEndian): T {.inline.} =
+  # TODO fromBytesBE in io.nim handles this better, merge the two!
+  var tmp: array[bits div 8, byte]
+  if x.len < tmp.len:
+    let offset = if endian == bigEndian: tmp.len - x.len else: 0
+    for i in 0..<x.len: # Loop since vm can't copymem
+      tmp[i + offset] = x[i]
+  else:
+    for i in 0..<tmp.len: # Loop since vm can't copymem
+      tmp[i] = x[i]
+  fromBytes(T, tmp, endian)
+
+func fromBytesBE*[bits: static int](
+    T: typedesc[StUint[bits]],
+    x: array[bits div 8, byte]): T {.inline.} =
+  ## Read big endian bytes and convert to an integer. By default, native
+  ## endianess is used which is not
+  ## portable!
+  fromBytes(T, x, bigEndian)
+
+func fromBytesBE*[bits: static int](
+    T: typedesc[StUint[bits]],
+    x: openArray[byte]): T {.inline.} =
+  ## Read big endian bytes and convert to an integer. At runtime, v must contain
+  ## at least sizeof(T) bytes. By default, native endianess is used which is not
+  ## portable!
+  fromBytes(T, x, bigEndian)
+
+func toBE*[bits: static int](x: StUint[bits]): StUint[bits] {.inline.} =
+  ## Convert a native endian value to big endian. Consider toBytesBE instead
+  ## which may prevent some confusion.
+  if cpuEndian == bigEndian: x
+  else: x.swapBytes
+
+func fromBE*[bits: static int](x: StUint[bits]): StUint[bits] {.inline.} =
+  ## Read a big endian value and return the corresponding native endian
+  # there's no difference between this and toBE, except when reading the code
+  toBE(x)
+
+func fromBytesLE*[bits: static int](
+    T: typedesc[StUint[bits]],
+    x: array[bits div 8, byte]): StUint[bits] {.inline.} =
+  ## Read little endian bytes and convert to an integer. By default, native
+  ## endianess is used which is not portable!
+  fromBytes(T, x, littleEndian)
+
+func fromBytesLE*[bits: static int](
+    T: typedesc[StUint[bits]],
+    x: openArray[byte]): StUint[bits] {.inline.} =
+  ## Read little endian bytes and convert to an integer. At runtime, v must
+  ## contain at least sizeof(T) bytes. By default, native endianess is used
+  ## which is not portable!
+  fromBytes(T, x, littleEndian)
+
+func toLE*[bits: static int](x: StUint[bits]): StUint[bits] {.inline.} =
+  ## Convert a native endian value to little endian. Consider toBytesLE instead
+  ## which may prevent some confusion.
+  if cpuEndian == littleEndian: x
+  else: x.swapBytes
+
+func fromLE*[bits: static int](x: StUint[bits]): StUint[bits] {.inline.} =
+  ## Read a little endian value and return the corresponding native endian
+  # there's no difference between this and toLE, except when reading the code
+  toLE(x)
diff --git a/stint/int_public.nim b/stint/int_public.nim
deleted file mode 100644
index 4dc7bfc..0000000
--- a/stint/int_public.nim
+++ /dev/null
@@ -1,94 +0,0 @@
-# Stint
-# Copyright 2018 Status Research & Development GmbH
-# Licensed under either of
-#
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-#
-# at your option. This file may not be copied, modified, or distributed except according to those terms.
-
-import ./private/datatypes
-export StInt
-export IntImpl, intImpl, bitsof # TODO remove the need to export these
-
-template make_unary(op, ResultTy): untyped =
-  func `op`*(x: Stint): ResultTy {.inline.} =
-    when ResultTy is Stint:
-      result.data = op(x.data)
-    else:
-      op(x.data)
-  export op
-
-template make_binary(op, ResultTy): untyped =
-  func `op`*(x, y: Stint): ResultTy {.inline.} =
-    when ResultTy is Stint:
-      result.data = op(x.data, y.data)
-    else:
-      op(x.data, y.data)
-  export `op`
-
-template make_binary_inplace(op): untyped =
-  func `op`*(x: var Stint, y: Stint) {.inline.} =
-    op(x.data, y.data)
-  export op
-
-import ./private/int_addsub
-
-make_binary(`+`, Stint)
-make_binary_inplace(`+=`)
-make_binary(`-`, Stint)
-make_binary_inplace(`-=`)
-
-import ./private/int_negabs
-make_unary(`-`, Stint)
-make_unary(abs, Stint)
-
-import ./private/int_mul
-make_binary(`*`, Stint)
-
-import ./private/int_div
-
-make_binary(`div`, Stint)
-make_binary(`mod`, Stint)
-func divmod*(x, y: Stint): tuple[quot, rem: Stint] {.inline.} =
-  (result.quot.data, result.rem.data) = divmod(x.data, y.data)
-
-import ./private/int_comparison
-
-make_binary(`<`, bool)
-make_binary(`<=`, bool)
-make_binary(`==`, bool)
-make_unary(isZero, bool)
-make_unary(isNegative, bool)
-
-func isOdd(x: SomeSignedInt): bool {.inline.}=
-  # internal
-  bool(x and 1)
-
-func isEven(x: SomeSignedInt): bool {.inline.}=
-  # internal
-  not x.isOdd
-
-make_unary(isOdd, bool)
-make_unary(isEven, bool)
-
-import ./private/int_bitwise_ops
-
-make_unary(`not`, Stint)
-make_binary(`or`, Stint)
-make_binary(`and`, Stint)
-make_binary(`xor`, Stint)
-func `shr`*(x: Stint, y: SomeInteger): Stint {.inline.} =
-  result.data = x.data shr y
-func `shl`*(x: Stint, y: SomeInteger): Stint {.inline.} =
-  result.data = x.data shl y
-func ashr*(x: Stint, y: SomeInteger): Stint {.inline.} =
-  result.data = ashr(x.data, y)
-
-import ./private/int_highlow
-
-func high*[bits: static[int]](_: typedesc[Stint[bits]]): Stint[bits] {.inline.} =
-  result.data = high(type result.data)
-
-func low*[bits: static[int]](_: typedesc[Stint[bits]]): Stint[bits] {.inline.} =
-  result.data = low(type result.data)
diff --git a/stint/intops.nim b/stint/intops.nim
new file mode 100644
index 0000000..5d22664
--- /dev/null
+++ b/stint/intops.nim
@@ -0,0 +1,159 @@
+# Stint
+# Copyright 2018 Status Research & Development GmbH
+# Licensed under either of
+#
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+#
+# at your option. This file may not be copied, modified, or distributed except according to those terms.
+
+import ./private/[bitops2_priv, datatypes]
+
+export Stint, StUint
+export IntImpl, intImpl, UintImpl, uintImpl, bitsof # TODO: remove the need to export those
+
+type SomeBigInteger = Stuint|Stint
+
+import ./private/initialization
+
+func zero*[bits: static[int]](T: typedesc[Stuint[bits] or Stint[bits]]): T {.inline.} =
+  ## Returns the zero of the input type
+  discard
+
+func one*[bits: static[int]](T: typedesc[Stuint[bits]]): T {.inline.} =
+  ## Returns the one of the input type
+  result.data = one(type result.data)
+
+import ./private/[int_addsub, uint_addsub]
+
+func `+`*(x, y: SomeBigInteger): SomeBigInteger {.inline.} =
+  ## Integer addition
+  result.data = x.data + y.data
+func `+=`*(x: var SomeBigInteger, y: SomeBigInteger) {.inline.} =
+  ## Integer addition
+  x.data += y.data
+func `-`*(x, y: SomeBigInteger): SomeBigInteger {.inline.} =
+  ## Integer substraction
+  result.data = x.data - y.data
+func `-=`*(x: var SomeBigInteger, y: SomeBigInteger) {.inline.} =
+  ## Integer substraction
+  x.data -= y.data
+
+import ./private/int_negabs
+
+func `-`*(x: Stint): Stint {.inline.} =
+  ## Returns true if input is zero
+  ## false otherwise
+  result.data = -x.data
+
+func abs*(x: Stint): Stint {.inline.} =
+  ## Returns true if input is zero
+  ## false otherwise
+  result.data = abs(x.data)
+
+import ./private/[int_mul, uint_mul]
+
+func `*`*(x, y: SomeBigInteger): SomeBigInteger {.inline.} =
+  ## Integer multiplication
+  result.data = x.data * y.data
+
+import ./private/[int_div, uint_div]
+
+func `div`*(x, y: SomeBigInteger): SomeBigInteger {.inline.} =
+  ## Integer division
+  result.data = x.data div y.data
+func `mod`*(x, y: SomeBigInteger): SomeBigInteger {.inline.} =
+  ## Integer modulo
+  ## This returns the remainder of x / y.
+  ## i.e. x = y * quotient + remainder
+  result.data = x.data mod y.data
+func divmod*(x, y: SomeBigInteger): tuple[quot, rem: SomeBigInteger] {.inline.} =
+  ## Fused integer division and modulo
+  ## Return both the quotient and remainder
+  ## of x / y
+  (result.quot.data, result.rem.data) = divmod(x.data, y.data)
+
+import ./private/[int_comparison, uint_comparison]
+
+func `<`*(x, y: SomeBigInteger): bool {.inline.} =
+  ## Unsigned `less than` comparison
+  x.data < y.data
+func `<=`*(x, y: SomeBigInteger): bool {.inline.} =
+  ## Unsigned `less or equal` comparison
+  x.data <= y.data
+func `==`*(x, y: SomeBigInteger): bool {.inline.} =
+  ## Unsigned `equal` comparison
+  x.data == y.data
+export `<`, `<=`, `==` # Address Generic Instantiation too nested: https://github.com/status-im/nim-stint/pull/66#issuecomment-427557655
+
+func isZero*(x: SomeBigInteger): bool {.inline.} =
+  ## Returns true if input is zero
+  ## false otherwise
+  x.data.isZero
+
+func isNegative*(x: SomeBigInteger): bool {.inline.} =
+  ## Returns true if input is negative (< 0)
+  ## false otherwise
+  x.data.isNegative
+
+func isOdd*(x: SomeBigInteger): bool {.inline.} =
+  ## Returns true if input is zero
+  ## false otherwise
+  x.data.isOdd
+
+func isEven*(x: SomeBigInteger): bool {.inline.} =
+  ## Returns true if input is zero
+  ## false otherwise
+  x.data.isEven
+
+export isEven, isOdd
+
+import ./private/[int_bitwise_ops, uint_bitwise_ops]
+
+func `not`*(x: SomeBigInteger): SomeBigInteger {.inline.}=
+  ## Bitwise `not` i.e. flips all bits of the input
+  result.data = x.data.not
+func `or`*(x, y: SomeBigInteger): SomeBigInteger {.inline.}=
+  ## Bitwise `or`
+  result.data = x.data or y.data
+func `and`*(x, y: SomeBigInteger): SomeBigInteger {.inline.}=
+  ## Bitwise `and`
+  result.data = x.data and y.data
+func `xor`*(x, y: SomeBigInteger): SomeBigInteger {.inline.}=
+  ## Bitwise `xor`
+  result.data = x.data xor y.data
+
+func `shr`*(x: SomeBigInteger, y: SomeInteger): SomeBigInteger {.inline.} =
+  result.data = x.data shr y
+func `shl`*(x: SomeBigInteger, y: SomeInteger): SomeBigInteger {.inline.} =
+  result.data = x.data shl y
+func ashr*(x: Stint, y: SomeInteger): Stint {.inline.} =
+  result.data = ashr(x.data, y)
+
+import ./private/[int_highlow, uint_highlow]
+
+func high*[bits](_: typedesc[Stint[bits]]): Stint[bits] {.inline.} =
+  result.data = high(type result.data)
+func high*[bits](_: typedesc[Stuint[bits]]): Stuint[bits] {.inline.} =
+  result.data = high(type result.data)
+
+func low*[bits](_: typedesc[Stint[bits]]): Stint[bits] {.inline.} =
+  result.data = low(type result.data)
+func low*[bits](_: typedesc[Stuint[bits]]): Stuint[bits] {.inline.} =
+  result.data = low(type result.data)
+
+import ./private/uint_exp, math
+
+func pow*(x: StUint, y: Natural): StUint {.inline.} =
+  ## Returns x raised at the power of y
+  when x.data is UintImpl:
+    result.data = x.data.pow(y)
+  else:
+    result.data = x.data ^ y
+
+func pow*(x: StUint, y: StUint): StUint {.inline.} =
+  ## Returns x raised at the power of y
+  when x.data is UintImpl:
+    result.data = x.data.pow(y.data)
+  else:
+    result.data = x.data ^ y.data
diff --git a/stint/io.nim b/stint/io.nim
index f792959..b4398dd 100644
--- a/stint/io.nim
+++ b/stint/io.nim
@@ -10,7 +10,7 @@
 import
   ./private/datatypes,
   ./private/int_negabs,
-  ./int_public, ./uint_public,
+  ./intops,
   typetraits, algorithm
 
 template static_check_size(T: typedesc[SomeInteger], bits: static[int]) =
diff --git a/stint/literals_stint.nim b/stint/literals_stint.nim
index 437b48c..297045f 100644
--- a/stint/literals_stint.nim
+++ b/stint/literals_stint.nim
@@ -9,7 +9,7 @@
 
 ## This file provides syntactic sugar to work with literals
 
-import ./int_public, ./uint_public, macros
+import ./intops, macros
 
 type Signedness = enum
   BothSigned, IntOnly, UintOnly
diff --git a/stint/modular_arithmetic.nim b/stint/modular_arithmetic.nim
index 2b0cc40..e39ec68 100644
--- a/stint/modular_arithmetic.nim
+++ b/stint/modular_arithmetic.nim
@@ -7,7 +7,7 @@
 #
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
-import ./uint_public
+import ./intops
 
 func addmod_internal(a, b, m: Stuint): Stuint {.inline.}=
   ## Modular addition
diff --git a/stint/private/bitops2.nim b/stint/private/bitops2_priv.nim
similarity index 70%
rename from stint/private/bitops2.nim
rename to stint/private/bitops2_priv.nim
index 8511077..0c2479f 100644
--- a/stint/private/bitops2.nim
+++ b/stint/private/bitops2_priv.nim
@@ -12,9 +12,27 @@ export bitops2
 
 # Bitops from support library
 
+template bitsof*(x: UintImpl): int =
+  # XXX: https://github.com/nim-lang/Nim/issues/9494
+  mixin bitsof
+  bitsof(x.lo) * 2
+
+template bitsof*(x: IntImpl): int =
+  # XXX: https://github.com/nim-lang/Nim/issues/9494
+  mixin bitsof
+  bitsof(x.lo) * 2
+
+template bitsof*(x: typedesc[UintImpl]): int =
+  # XXX: https://github.com/nim-lang/Nim/issues/9494
+  mixin bitsof
+  bitsof(x.lo) * 2
+
 func countOnes*(x: UintImpl): int {.inline.} =
   countOnes(x.lo) + countOnes(x.hi)
 
+func countZeros*(x: UintImpl): int {.inline.} =
+  countZeros(x.lo) + countOnes(x.hi)
+
 func parity*(x: UintImpl): int {.inline.} =
   parity(x.lo) xor parity(x.hi)
 
diff --git a/stint/private/datatypes.nim b/stint/private/datatypes.nim
index 2d4fac9..7e44409 100644
--- a/stint/private/datatypes.nim
+++ b/stint/private/datatypes.nim
@@ -166,14 +166,6 @@ type
   StInt*[bits: static[int]] = object
     data*: intImpl(bits)
 
-
-template bitsof*(x: SomeInteger): untyped =
-  sizeof(x) * 8
-template bitsof*(x: UintImpl|IntImpl): untyped =
-  # XXX: https://github.com/nim-lang/Nim/issues/9494
-  mixin bitsof
-  bitsof(x.lo) * 2
-
 template applyHiLo*(a: UintImpl | IntImpl, c: untyped): untyped =
   ## Apply `c` to each of `hi` and `lo`
   var res: type a
diff --git a/stint/private/endians2_priv.nim b/stint/private/endians2_priv.nim
new file mode 100644
index 0000000..8abf73f
--- /dev/null
+++ b/stint/private/endians2_priv.nim
@@ -0,0 +1,21 @@
+import ./bitops2_priv, ./datatypes
+
+import stew/endians2
+export endians2
+
+func swapBytes*(x: UintImpl): UintImpl {.inline.} =
+  let lo = swapBytes(x.hi)
+  let hi = swapBytes(x.lo)
+
+  UintImpl(hi: hi, lo: lo)
+
+func toBytes*(x: UintImpl, endian: Endianness = system.cpuEndian): auto {.inline.} =
+  # TODO can't use bitsof in return type (compiler bug?), hence return auto
+  # TODO compile-time version
+  var ret: array[bitsof(x) div 8, byte]
+  if endian == system.cpuEndian:
+    copyMem(addr ret[0], unsafeAddr x, ret.len)
+  else:
+    let v = swapBytes(x)
+    copyMem(addr ret[0], unsafeAddr v, ret.len)
+  ret
diff --git a/stint/private/int_bitwise_ops.nim b/stint/private/int_bitwise_ops.nim
index 0c0b15d..fe10870 100644
--- a/stint/private/int_bitwise_ops.nim
+++ b/stint/private/int_bitwise_ops.nim
@@ -7,7 +7,7 @@
 #
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
-import  ./datatypes, ./uint_bitwise_ops
+import  ./datatypes, ./bitops2_priv, ./uint_bitwise_ops
 
 func `not`*(x: IntImpl): IntImpl {.inline.}=
   ## Bitwise complement of unsigned integer x
diff --git a/stint/private/int_comparison.nim b/stint/private/int_comparison.nim
index 0b2e8f1..2f4adf9 100644
--- a/stint/private/int_comparison.nim
+++ b/stint/private/int_comparison.nim
@@ -36,6 +36,12 @@ func `<=`*(x, y: IntImpl): bool {.inline.}=
   x.hi < y.hi or
     (x.hi == y.hi and x.lo <= y.lo)
 
+func isOdd*(x: SomeSignedInt): bool {.inline.}=
+  bool(x and 1)
+
+func isEven*(x: SomeSignedInt): bool {.inline.}=
+  not x.isOdd
+
 func isEven*(x: IntImpl): bool {.inline.}=
   x.lo.isEven
 
diff --git a/stint/private/int_negabs.nim b/stint/private/int_negabs.nim
index 5e2caba..8803123 100644
--- a/stint/private/int_negabs.nim
+++ b/stint/private/int_negabs.nim
@@ -10,7 +10,7 @@
 import
   ./datatypes,
   ./initialization, ./int_highlow,
-  ./int_addsub, ./int_comparison
+  ./int_addsub, ./int_comparison, ./int_bitwise_ops
 
 func `-`*(x: IntImpl): IntImpl {.inline.}=
   # Negate a multi-precision signed int.
diff --git a/stint/private/uint_bitwise_ops.nim b/stint/private/uint_bitwise_ops.nim
index 145898f..d208e52 100644
--- a/stint/private/uint_bitwise_ops.nim
+++ b/stint/private/uint_bitwise_ops.nim
@@ -7,7 +7,7 @@
 #
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
-import  ./datatypes
+import  ./datatypes, ./bitops2_priv
 
 func `not`*(x: UintImpl): UintImpl {.inline.}=
   ## Bitwise complement of unsigned integer x
diff --git a/stint/private/uint_div.nim b/stint/private/uint_div.nim
index 814b8c1..76ff545 100644
--- a/stint/private/uint_div.nim
+++ b/stint/private/uint_div.nim
@@ -7,7 +7,7 @@
 #
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
-import  ./bitops2, ./conversion, ./initialization,
+import  ./bitops2_priv, ./conversion, ./initialization,
         ./datatypes,
         ./uint_comparison,
         ./uint_bitwise_ops,
diff --git a/stint/uint_public.nim b/stint/uint_public.nim
deleted file mode 100644
index 0851360..0000000
--- a/stint/uint_public.nim
+++ /dev/null
@@ -1,146 +0,0 @@
-# Stint
-# Copyright 2018 Status Research & Development GmbH
-# Licensed under either of
-#
-#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-#
-# at your option. This file may not be copied, modified, or distributed except according to those terms.
-
-import ./private/datatypes
-
-export StUint
-export UintImpl, uintImpl, bitsof # TODO: remove the need to export those
-
-import ./private/uint_addsub
-
-func `+`*(x, y: Stuint): Stuint {.inline.} =
-  ## Unsigned integer addition
-  result.data = x.data + y.data
-func `+=`*(x: var Stuint, y: Stuint) {.inline.} =
-  ## Unsigned integer addition
-  x.data += y.data
-func `-`*(x, y: Stuint): Stuint {.inline.} =
-  ## Unsigned integer substraction
-  result.data = x.data - y.data
-func `-=`*(x: var Stuint, y: Stuint) {.inline.} =
-  ## Unsigned integer substraction
-  x.data -= y.data
-
-import ./private/uint_mul
-
-func `*`*(x, y: Stuint): Stuint {.inline.} =
-  ## Unsigned integer multiplication
-  result.data = x.data * y.data
-
-import ./private/uint_div
-
-func `div`*(x, y: Stuint): Stuint {.inline.} =
-  ## Unsigned integer division
-  result.data = x.data div y.data
-func `mod`*(x, y: Stuint): Stuint {.inline.} =
-  ## Unsigned integer modulo
-  ## This returns the remainder of x / y.
-  ## i.e. x = y * quotient + remainder
-  result.data = x.data mod y.data
-func divmod*(x, y: StUint): tuple[quot, rem: StUint] {.inline.} =
-  ## Fused unsigned integer division and modulo
-  ## Return both the quotient and remainder
-  ## of x / y
-  (result.quot.data, result.rem.data) = divmod(x.data, y.data)
-
-import ./private/uint_comparison
-
-func `<`*(x, y: Stuint): bool {.inline.} =
-  ## Unsigned `less than` comparison
-  x.data < y.data
-func `<=`*(x, y: Stuint): bool {.inline.} =
-  ## Unsigned `less or equal` comparison
-  x.data <= y.data
-func `==`*(x, y: Stuint): bool {.inline.} =
-  ## Unsigned `equal` comparison
-  x.data == y.data
-export `<`, `<=`, `==` # Address Generic Instantiation too nested: https://github.com/status-im/nim-stint/pull/66#issuecomment-427557655
-
-func isZero*(x: Stuint): bool {.inline.} =
-  ## Returns true if input is zero
-  ## false otherwise
-  x.data.isZero
-
-export isEven, isOdd
-func isEven*(x: Stuint): bool {.inline.}=
-  ## Returns true if input is even
-  ## false otherwise
-  x.data.isEven
-func isOdd*(x: Stuint): bool {.inline.}=
-  ## Returns true if input is odd
-  ## false otherwise
-  not x.isEven
-
-import ./private/uint_bitwise_ops
-
-func `not`*(x: Stuint): Stuint {.inline.}=
-  ## Bitwise `not` i.e. flips all bits of the input
-  result.data = x.data.not
-func `or`*(x, y: Stuint): Stuint {.inline.}=
-  ## Bitwise `or`
-  result.data = x.data or y.data
-func `and`*(x, y: Stuint): Stuint {.inline.}=
-  ## Bitwise `and`
-  result.data = x.data and y.data
-func `xor`*(x, y: Stuint): Stuint {.inline.}=
-  ## Bitwise `xor`
-  result.data = x.data xor y.data
-
-func `shr`*(x: StUint, y: SomeInteger): StUint {.inline.} =
-  ## Logical shift right
-  result.data = x.data shr y
-func `shl`*(x: StUint, y: SomeInteger): StUint {.inline.} =
-  ## Logical shift right
-  ## Similar to C standard, result is undefined if y is bigger
-  ## than the number of bits in x.
-  result.data = x.data shl y
-
-import ./private/uint_highlow
-
-func high*[bits: static[int]](_: typedesc[Stuint[bits]]): Stuint[bits] {.inline.} =
-  ## Returns the highest unsigned int of this size. I.e. bits are all ones.
-  result.data = high(type result.data)
-
-func low*[bits: static[int]](_: typedesc[Stuint[bits]]): Stuint[bits] {.inline.} =
-  ## Returns the lowest unsigned int of this size. This is always 0.
-  result.data = low(type result.data)
-
-import ./private/bitops2
-
-func countOnes*(x: StUint): int {.inline.} = countOnes(x.data)
-func parity*(x: StUint): int {.inline.} = parity(x.data)
-func firstOne*(x: StUint): int {.inline.} = firstOne(x.data)
-func leadingZeros*(x: StUint): int {.inline.} = leadingZeros(x.data)
-func trailingZeros*(x: StUint): int {.inline.} = trailingZeros(x.data)
-
-import ./private/initialization
-
-func zero*[bits: static[int]](T: typedesc[Stuint[bits] or Stint[bits]]): T {.inline.} =
-  ## Returns the zero of the input type
-  discard
-
-func one*[bits: static[int]](T: typedesc[Stuint[bits]]): T {.inline.} =
-  ## Returns the one of the input type
-  result.data = one(type result.data)
-
-import ./private/uint_exp, math
-
-func pow*(x: StUint, y: Natural): StUint {.inline.} =
-  ## Returns x raised at the power of y
-  when x.data is UintImpl:
-    result.data = x.data.pow(y)
-  else:
-    result.data = x.data ^ y
-
-func pow*(x: StUint, y: StUint): StUint {.inline.} =
-  ## Returns x raised at the power of y
-  when x.data is UintImpl:
-    result.data = x.data.pow(y.data)
-  else:
-    result.data = x.data ^ y.data
diff --git a/tests/test_uint_endians2.nim b/tests/test_uint_endians2.nim
new file mode 100644
index 0000000..dabd5f8
--- /dev/null
+++ b/tests/test_uint_endians2.nim
@@ -0,0 +1,26 @@
+# Stint
+# Copyright 2018 Status Research & Development GmbH
+# Licensed under either of
+#
+#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+#
+# at your option. This file may not be copied, modified, or distributed except according to those terms.
+
+import ../stint, unittest
+
+suite "Testing endians":
+  test "Endians give sane results":
+
+    check:
+      1.u128.toBytesBE() ==
+        [0'u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+
+      1.u128.toBytesLE() ==
+        [1'u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+      1.u128 == UInt128.fromBytesBE(
+        [0'u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+
+      1.u128 == UInt128.fromBytesLE(
+        [1'u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])