From eea07542efb72ae55f9f4a081e59798ba8344b1f Mon Sep 17 00:00:00 2001
From: Giuseppe Barbieri <elect86@gmail.com>
Date: Thu, 2 Nov 2023 19:48:39 +0100
Subject: [PATCH] 3.4.0

---
 .idea/gradle.xml                              |  13 +-
 .idea/kotlinc.xml                             |   2 +-
 .idea/misc.xml                                |   4 +-
 .kotlintest/spec_failures                     |   0
 .travis.yml                                   |   3 -
 README.md                                     |  11 +-
 build.gradle.kts                              |  87 ++--
 buildSrc/build.gradle.kts                     |   7 +
 buildSrc/settings.gradle.kts                  |   1 +
 buildSrc/src/main/kotlin/uns/arrays.kt        |  63 +++
 buildSrc/src/main/kotlin/uns/extensions.kt    |  47 ++
 .../src/main/kotlin/uns/gen/GenerateCode.kt   |  65 +++
 buildSrc/src/main/kotlin/uns/gen/Generator.kt | 155 ++++++
 buildSrc/src/main/kotlin/uns/operators.kt     |  87 ++++
 buildSrc/src/main/kotlin/uns/types.kt         | 281 +++++++++++
 buildSrc/src/main/kotlin/uns/util.kt          |  97 ++++
 gradle/wrapper/gradle-wrapper.properties      |   4 +-
 jitpack.yml                                   |   6 -
 settings.gradle.kts                           |   2 +-
 src/commonMain/kotlin/uns/BigInt.kt           |  10 +
 src/commonMain/kotlin/uns/aliases.kt          |  12 +
 .../kotlin/uns/format/ExponentFormatter.kt    | 157 +++++++
 .../kotlin/uns/format/Specification.kt        | 317 +++++++++++++
 src/commonMain/kotlin/uns/format/Sprintf.kt   | 105 +++++
 src/commonMain/kotlin/unsigned/Byte.kt        | 105 +++++
 src/commonMain/kotlin/unsigned/Int.kt         | 118 +++++
 src/commonMain/kotlin/unsigned/Long.kt        | 139 ++++++
 src/commonMain/kotlin/unsigned/Short.kt       | 104 +++++
 src/commonMain/kotlin/unsigned/Ubyte.kt       | 107 +++++
 src/commonMain/kotlin/unsigned/Uint.kt        |  91 ++++
 src/commonMain/kotlin/unsigned/Ulong.kt       | 107 +++++
 src/commonMain/kotlin/unsigned/Ushort.kt      | 108 +++++
 src/commonMain/kotlin/unsigned/unsigned.kt    |  19 +
 src/commonTest/kotlin/unsigned/test.kt        |  90 ++++
 src/commonTest/kotlin/unsigned/u16_test.kt    | 146 ++++++
 src/commonTest/kotlin/unsigned/u32_test.kt    | 133 ++++++
 src/commonTest/kotlin/unsigned/u8_test.kt     | 147 ++++++
 src/commonTest/kotlin/unsigned/ulong.kt       | 126 +++++
 src/commonTest/kotlin/unsigned/utils.kt       |   5 +
 src/genCommonMain/kotlin/uns/U16.kt           | 364 +++++++++++++++
 src/genCommonMain/kotlin/uns/U32.kt           | 364 +++++++++++++++
 src/genCommonMain/kotlin/uns/U64.kt           | 364 +++++++++++++++
 src/genCommonMain/kotlin/uns/U8.kt            | 364 +++++++++++++++
 src/genCommonMain/kotlin/uns/arrays.kt        | 147 ++++++
 src/genCommonMain/kotlin/uns/extensions.kt    | 442 ++++++++++++++++++
 src/genCommonMain/kotlin/uns/operators.kt     | 381 +++++++++++++++
 src/main/kotlin/module-info                   |   6 -
 src/main/kotlin/unsigned/BigInteger.kt        |  10 -
 src/main/kotlin/unsigned/Byte.kt              | 109 -----
 src/main/kotlin/unsigned/Int.kt               | 122 -----
 src/main/kotlin/unsigned/Long.kt              | 132 ------
 src/main/kotlin/unsigned/Short.kt             | 108 -----
 src/main/kotlin/unsigned/Ubyte.kt             | 106 -----
 src/main/kotlin/unsigned/Uint.kt              |  91 ----
 src/main/kotlin/unsigned/Ulong.kt             | 107 -----
 src/main/kotlin/unsigned/Ushort.kt            | 104 -----
 src/main/kotlin/unsigned/arrays.kt            |  56 ---
 src/main/kotlin/unsigned/unsigned.kt          |  19 -
 src/test/kotlin/unsigned/test.kt              |  93 ----
 src/test/kotlin/unsigned/ubyte.kt             | 138 ------
 src/test/kotlin/unsigned/uint.kt              | 131 ------
 src/test/kotlin/unsigned/ulong.kt             | 124 -----
 src/test/kotlin/unsigned/ushort.kt            | 141 ------
 63 files changed, 5452 insertions(+), 1652 deletions(-)
 delete mode 100644 .kotlintest/spec_failures
 delete mode 100644 .travis.yml
 create mode 100644 buildSrc/build.gradle.kts
 create mode 100644 buildSrc/settings.gradle.kts
 create mode 100644 buildSrc/src/main/kotlin/uns/arrays.kt
 create mode 100644 buildSrc/src/main/kotlin/uns/extensions.kt
 create mode 100644 buildSrc/src/main/kotlin/uns/gen/GenerateCode.kt
 create mode 100644 buildSrc/src/main/kotlin/uns/gen/Generator.kt
 create mode 100644 buildSrc/src/main/kotlin/uns/operators.kt
 create mode 100644 buildSrc/src/main/kotlin/uns/types.kt
 create mode 100644 buildSrc/src/main/kotlin/uns/util.kt
 delete mode 100644 jitpack.yml
 create mode 100644 src/commonMain/kotlin/uns/BigInt.kt
 create mode 100644 src/commonMain/kotlin/uns/aliases.kt
 create mode 100644 src/commonMain/kotlin/uns/format/ExponentFormatter.kt
 create mode 100644 src/commonMain/kotlin/uns/format/Specification.kt
 create mode 100644 src/commonMain/kotlin/uns/format/Sprintf.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Byte.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Int.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Long.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Short.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Ubyte.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Uint.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Ulong.kt
 create mode 100644 src/commonMain/kotlin/unsigned/Ushort.kt
 create mode 100644 src/commonMain/kotlin/unsigned/unsigned.kt
 create mode 100644 src/commonTest/kotlin/unsigned/test.kt
 create mode 100644 src/commonTest/kotlin/unsigned/u16_test.kt
 create mode 100644 src/commonTest/kotlin/unsigned/u32_test.kt
 create mode 100644 src/commonTest/kotlin/unsigned/u8_test.kt
 create mode 100644 src/commonTest/kotlin/unsigned/ulong.kt
 create mode 100644 src/commonTest/kotlin/unsigned/utils.kt
 create mode 100644 src/genCommonMain/kotlin/uns/U16.kt
 create mode 100644 src/genCommonMain/kotlin/uns/U32.kt
 create mode 100644 src/genCommonMain/kotlin/uns/U64.kt
 create mode 100644 src/genCommonMain/kotlin/uns/U8.kt
 create mode 100644 src/genCommonMain/kotlin/uns/arrays.kt
 create mode 100644 src/genCommonMain/kotlin/uns/extensions.kt
 create mode 100644 src/genCommonMain/kotlin/uns/operators.kt
 delete mode 100644 src/main/kotlin/module-info
 delete mode 100644 src/main/kotlin/unsigned/BigInteger.kt
 delete mode 100644 src/main/kotlin/unsigned/Byte.kt
 delete mode 100644 src/main/kotlin/unsigned/Int.kt
 delete mode 100644 src/main/kotlin/unsigned/Long.kt
 delete mode 100644 src/main/kotlin/unsigned/Short.kt
 delete mode 100644 src/main/kotlin/unsigned/Ubyte.kt
 delete mode 100644 src/main/kotlin/unsigned/Uint.kt
 delete mode 100644 src/main/kotlin/unsigned/Ulong.kt
 delete mode 100644 src/main/kotlin/unsigned/Ushort.kt
 delete mode 100644 src/main/kotlin/unsigned/arrays.kt
 delete mode 100644 src/main/kotlin/unsigned/unsigned.kt
 delete mode 100644 src/test/kotlin/unsigned/test.kt
 delete mode 100644 src/test/kotlin/unsigned/ubyte.kt
 delete mode 100644 src/test/kotlin/unsigned/uint.kt
 delete mode 100644 src/test/kotlin/unsigned/ulong.kt
 delete mode 100644 src/test/kotlin/unsigned/ushort.kt

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index eaa4f33..c97a46c 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -4,13 +4,24 @@
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
+        <compositeConfiguration>
+          <compositeBuild compositeDefinitionSource="SCRIPT">
+            <builds>
+              <build path="$PROJECT_DIR$/buildSrc" name="buildSrc">
+                <projects>
+                  <project path="$PROJECT_DIR$/buildSrc" />
+                </projects>
+              </build>
+            </builds>
+          </compositeBuild>
+        </compositeConfiguration>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
         <option name="gradleHome" value="$USER_HOME$/.gradle/wrapper/dists/gradle-7.0-milestone-1-all/1mxcarbtzx809qy5j35if8v52/gradle-7.0-milestone-1" />
         <option name="gradleJvm" value="openjdk-16" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/buildSrc" />
           </set>
         </option>
       </GradleProjectSettings>
diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
index fdf8d99..f8467b4 100644
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.9.0" />
+    <option name="version" value="1.9.10" />
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 5821b2f..bc8da91 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,8 +1,10 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="FrameworkDetectionExcludesConfiguration">
     <file type="web" url="file://$PROJECT_DIR$" />
   </component>
   <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK" />
+  <component name="SuppressKotlinCodeStyleNotification">
+    <option name="disableForAll" value="true" />
+  </component>
 </project>
\ No newline at end of file
diff --git a/.kotlintest/spec_failures b/.kotlintest/spec_failures
deleted file mode 100644
index e69de29..0000000
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 94d2a22..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-language: java
-jdk:
-  - openjdk11
diff --git a/README.md b/README.md
index aebaa0f..f85ae89 100644
--- a/README.md
+++ b/README.md
@@ -17,17 +17,16 @@ To have a quick idea what this library offers, take a look at the [tests](https:
 
 ### Differences with kotlin stdlib: 
 
-- this project uses classes instead inline classes. To address this in critical scenarios where allocations may have a sensitive impact, primitive variable holding the utype value is a `var`, so you can re-use the same istance over and over again
-- utypes extend `Number` abstract class
+- this project uses classes instead inline classes. To address this in critical scenarios where allocations may have a sensitive impact, primitive variable holding the unsigned 
+type value is a `var`, so you can re-use the same instance over and over again
+- unsigned types extend `Number` abstract class
 - automatic conversions
 - it is possible to string format by calling the corresponding `format()` method, eg: `ubyte.format("%08x")`
-- all the utypes implement all the function, including `shl` and `shr` for `Ubyte` and `Ushort`
-- if you add an `Ushort` to another `Ushort` you get an `Ushort` (and not an `Uint`)
+- all the unsigned types implement all the function, including `shl` and `shr` for `Ubyte` and `Ushort`
+- there is no automatic padding to integer for unsigned bytes and shorts, so if you add an `Ushort` to another `Ushort` you get an `Ushort` (and not an `Uint`)
 
 ### Install:
 
-With Gradle `kx.util` plugin, everything is nicely aligned and the boilerplate code is gone
-
 #### mary
 ```kotlin
 repositories {
diff --git a/build.gradle.kts b/build.gradle.kts
index 599223d..f166be6 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,27 +1,59 @@
 import magik.createGithubPublication
 import magik.github
 import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
+import uns.gen.GenerateCode
 import java.util.*
 
 plugins {
-    kotlin("jvm") version embeddedKotlinVersion
+    kotlin("multiplatform") version embeddedKotlinVersion
     id("elect86.magik") version "0.3.3"
     `maven-publish`
     signing
     `jvm-test-suite`
-//    id("com.github.johnrengelman.shadow") version "8.1.1"
+    //    id("com.github.johnrengelman.shadow") version "8.1.1"
 }
 
 repositories { mavenCentral() }
 
-dependencies {
-    testImplementation("io.kotest:kotest-runner-junit5:5.7.1")
-    testImplementation("io.kotest:kotest-assertions-core:5.7.1")
+kotlin {
+    jvm {
+        jvmToolchain(11)
+        withJava()
+    }
+    val hostOs = System.getProperty("os.name")
+    val isArm64 = System.getProperty("os.arch") == "aarch64"
+    val isMingwX64 = hostOs.startsWith("Windows")
+    val nativeTarget = when {
+        hostOs == "Mac OS X" && isArm64 -> macosArm64("native")
+        hostOs == "Mac OS X" && !isArm64 -> macosX64("native")
+        hostOs == "Linux" && isArm64 -> linuxArm64("native")
+        hostOs == "Linux" && !isArm64 -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
+    sourceSets {
+        val commonMain by getting {
+            dependencies {
+                implementation("com.ionspin.kotlin:bignum:0.3.8")
+            }
+        }
+        val commonTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
+        val jvmMain by getting
+        val jvmTest by getting
+        //        val jsMain by getting
+        //        val jsTest by getting
+        val nativeMain by getting
+        val nativeTest by getting
+    }
 }
 
-kotlin.jvmToolchain { languageVersion.set(JavaLanguageVersion.of(11)) }
-
 tasks {
+    val generateCode by registering(GenerateCode::class)
+    kotlin.sourceSets.commonMain { kotlin.srcDir(generateCode) }
     withType<KotlinCompile<*>>().all { kotlinOptions { freeCompilerArgs += listOf("-opt-in=kotlin.RequiresOptIn") } }
 }
 
@@ -29,15 +61,15 @@ testing.suites {
     val test by getting(JvmTestSuite::class) { useJUnitJupiter() }
 }
 
-java {
-    withJavadocJar()
-    withSourcesJar()
-}
+//java {
+//    withJavadocJar()
+//    withSourcesJar()
+//}
 
 
 configure<PublishingExtension> {
     publications {
-        createGithubPublication("Github") {
+        createGithubPublication {
             from(components["java"])
             suppressAllPomMetadataWarnings()
         }
@@ -50,31 +82,18 @@ configure<PublishingExtension> {
                 usage("java-runtime") { fromResolutionResult() }
             }
             pom {
-                name.set("kotlin-unsigned")
-                description.set("unsigned support for Kotlin via boxed types and unsigned operators")
-                url.set("https://github.com/kotlin-graphics/kotlin-unsigned")
-                licenses {
-                    license {
-                        name.set("MIT")
-                        url.set("https://choosealicense.com/licenses/mit/")
-                    }
-                }
+                name = "kotlin-unsigned"
+                description = "unsigned support for Kotlin via boxed types and unsigned operators"
+                url = "https://github.com/kotlin-graphics/kotlin-unsigned"
+                licenses { license { name = "MIT"; url = "https://choosealicense.com/licenses/mit/" } }
                 developers {
-                    developer {
-                        id.set("elect86")
-                        name.set("Giuseppe Barbieri")
-                        email.set("elect86@gmail.com")
-                    }
-                    developer {
-                        id.set("bixilon")
-                        name.set("Moritz Zwerger")
-                        email.set("bixilon@bixilon.de")
-                    }
+                    developer { id = "elect86"; name = "Giuseppe Barbieri"; email = "elect86@gmail.com" }
+                    developer { id = "bixilon"; name = "Moritz Zwerger"; email = "bixilon@bixilon.de" }
                 }
                 scm {
-                    connection.set("scm:git:https://github.com/kotlin-graphics/kotlin-unsigned.git")
-                    developerConnection.set("scm:git:ssh://git@github.com:kotlin-graphics/kotlin-unsigned.git")
-                    url.set("https://github.com/kotlin-graphics/kotlin-unsigned")
+                    connection = "scm:git:https://github.com/kotlin-graphics/kotlin-unsigned.git"
+                    developerConnection = "scm:git:ssh://git@github.com:kotlin-graphics/kotlin-unsigned.git"
+                    url = "https://github.com/kotlin-graphics/kotlin-unsigned"
                 }
             }
         }
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
new file mode 100644
index 0000000..cc02e63
--- /dev/null
+++ b/buildSrc/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+}
diff --git a/buildSrc/settings.gradle.kts b/buildSrc/settings.gradle.kts
new file mode 100644
index 0000000..3f87d39
--- /dev/null
+++ b/buildSrc/settings.gradle.kts
@@ -0,0 +1 @@
+rootProject.name = "buildSrc"
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/uns/arrays.kt b/buildSrc/src/main/kotlin/uns/arrays.kt
new file mode 100644
index 0000000..8d8ad83
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/arrays.kt
@@ -0,0 +1,63 @@
+package uns
+
+import uns.gen.Generator
+import uns.gen.generate
+
+fun arrays() {
+    generate("arrays") {
+        imports += "kotlin.jvm.JvmInline"
+        imports += "kotlin.jvm.JvmName"
+        imports += "kotlin.experimental.ExperimentalTypeInference"
+        experimentals += Generator.Experimentals.UnsignedTypes
+        experimentals += Generator.Experimentals.TypeInference
+        for (info in unsInfos) {
+            val Type = info.type
+            val TypeArray = Type + "Array"
+            val CounterArray = info.counterType + "Array"
+            val CounterType = info.counterType
+            +"""
+                @JvmInline
+                value class $TypeArray(val data: $CounterArray) {
+                
+                    operator fun get(index: I32): $Type = $Type(data[index])
+                
+                    operator fun set(index: I32, value: $Type) { data[index] = value.v }
+                    
+                    val indices: IntRange
+                        get() = data.indices
+                }
+                
+                fun $TypeArray(size: I32): $TypeArray = $TypeArray($CounterArray(size))
+                @OverloadResolutionByLambdaReturnType
+                @JvmName("$TypeArray$CounterType")
+                inline fun $TypeArray(size: I32, init: (I32) -> $CounterType): $TypeArray = $TypeArray($CounterArray(size, init))
+                @OverloadResolutionByLambdaReturnType
+                @JvmName("$TypeArray$Type")
+                inline fun $TypeArray(size: I32, init: (I32) -> $Type): $TypeArray {
+                    val array = $TypeArray($CounterArray(size))
+                    for (i in array.indices)
+                        array[i] = init(i)
+                    return array
+                }"""
+            if (info.bits != 32)
+                +"""
+                    @OverloadResolutionByLambdaReturnType
+                    @JvmName("${TypeArray}I32")
+                    inline fun $TypeArray(size: I32, init: (I32) -> I32): $TypeArray {
+                        val array = $TypeArray($CounterArray(size))
+                        for (i in array.indices)
+                            array.data[i] = init(i).to$CounterType()
+                        return array
+                    }
+                    @OverloadResolutionByLambdaReturnType
+                    @JvmName("${TypeArray}U32")
+                    inline fun $TypeArray(size: I32, init: (I32) -> U32): $TypeArray {
+                        val array = $TypeArray($CounterArray(size))
+                        for (i in array.indices)
+                            array.data[i] = init(i).to$CounterType()
+                        return array
+                    }"""
+        }
+    }
+}
+
diff --git a/buildSrc/src/main/kotlin/uns/extensions.kt b/buildSrc/src/main/kotlin/uns/extensions.kt
new file mode 100644
index 0000000..5404377
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/extensions.kt
@@ -0,0 +1,47 @@
+package uns
+
+import org.gradle.configurationcache.extensions.capitalized
+import uns.gen.generate
+
+fun extensions() {
+
+    generate("extensions") {
+
+        imports += "com.ionspin.kotlin.bignum.integer.toBigInteger"
+
+        for (receiver in intTypeInfos + kotlinUnsTypeInfo) {
+            val ReceiverType = receiver.type
+            for (extInfo in intTypeInfos + kotlinUnsTypeInfo + floatingTypes) {
+                val ext = extInfo.extension
+                val extType = extInfo.type
+                val ExtType = when {
+                    extInfo.isKotlinUns -> extInfo.type
+                    else -> ext.capitalized()
+                }
+                val toType = when {
+                    ReceiverType == "BigInt" -> when {
+                        extInfo.isUx -> "$ExtType(${extInfo.counterType.lowercase()}Value())"
+                        else -> extInfo.type.lowercase() + "Value()"
+                    }
+                    extInfo.isUx -> "$ExtType(this)"
+                    extInfo.type == "BigInt" -> if (receiver.isUx) "toBigInt()" else "toBigInteger()"
+                    else -> "to$extType()"
+                }
+                if (ReceiverType != extType) {
+                    +"""
+                        inline val $ReceiverType.$ext: $ExtType
+                            get() = $toType
+                        """
+                    fun alias(alias: Char) = +"""
+                        inline val $ReceiverType.$alias: $ExtType
+                            get() = $ext"""
+                    when (ext) {
+                        "i32" -> alias('i')
+                        "i64" -> alias('L')
+                        "f32" -> alias('f')
+                    }
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/uns/gen/GenerateCode.kt b/buildSrc/src/main/kotlin/uns/gen/GenerateCode.kt
new file mode 100644
index 0000000..58ee54e
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/gen/GenerateCode.kt
@@ -0,0 +1,65 @@
+package uns.gen
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.Directory
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.file.ProjectLayout
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import uns.arrays
+import uns.extensions
+import uns.operators
+import uns.types
+import javax.inject.Inject
+
+abstract class GenerateCode : DefaultTask() {
+
+    init {
+        group = "build"
+        description = "Generate uns code"
+    }
+
+    @get:Inject
+    abstract val layout: ProjectLayout
+
+    @get:Inject
+    abstract val files: FileSystemOperations
+
+    @get:OutputDirectory
+    val targetDir: Directory = layout.projectDirectory.dir("src/genCommonMain/kotlin")
+
+    @TaskAction
+    fun generate() {
+        Generator.targetDir = targetDir.asFile
+
+        files.delete { delete(Generator.targetDir) }
+        //        val targetJvm = targetJvmDir.get().asFile
+        //        val targetNonJvm = targetNonJvmDir.get().asFile
+        arrays()
+        types()
+        extensions()
+        operators()
+    }
+}
+
+fun generate(file: String, block: Generator.() -> Unit) {
+    Generator().apply {
+        block()
+        if (imports.isNotEmpty())
+            builder.insert(0, '\n')
+        for (import in imports)
+            builder.insert(0, "import $import\n")
+        //        if (`package`.isNotEmpty())
+        val f = file.replace('/', '.').substringBefore('.', "")
+        val pack = if (f.isEmpty()) "uns" else "uns.$f"
+        builder.insert(0, "package $pack\n\n")
+        if (experimentals.isNotEmpty()) {
+            val list = experimentals.joinToString { "${it.pkg}.Experimental${it.name}::class" }
+            builder.insert(0, "@file:OptIn($list)\n")
+        }
+        if (disableNameShadowing) builder.insert(0, "@file:Suppress(\"NAME_SHADOWING\")\n")
+        if (nothingToInline) builder.insert(0, "@file:Suppress(\"NOTHING_TO_INLINE\")\n")
+        write(file)
+    }
+}
+
diff --git a/buildSrc/src/main/kotlin/uns/gen/Generator.kt b/buildSrc/src/main/kotlin/uns/gen/Generator.kt
new file mode 100644
index 0000000..fdbdf38
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/gen/Generator.kt
@@ -0,0 +1,155 @@
+package uns.gen
+
+import java.io.File
+import java.util.*
+import kotlin.collections.HashSet
+
+class Generator {
+
+    val builder = StringBuilder()
+    var indentation = ""
+
+    var `package` = ""
+    var imports = HashSet<String>()
+    val experimentals = HashSet<Experimentals>()
+    var disableNameShadowing = false
+    var nothingToInline = false
+
+    fun String.indented(block: () -> Unit) {
+        +this
+        indent {
+            block()
+        }
+    }
+
+    fun String.indentAndClose(block: () -> Unit) {
+        indented(block)
+        when (last()) {
+            '(' -> builder.insert(builder.lastIndex, ')')
+            else -> +"}"
+        }
+    }
+
+    fun indent(block: () -> Unit) {
+        indentation += "\t"
+        block()
+        indentation = indentation.dropLast(1)
+    }
+
+    operator fun String.unaryPlus() {
+        var aligned = ""
+        var spaces = 0
+        var lineStart = this[0]
+        var lastC = '\u0000'
+        val parenthesis = Stack<Int>()
+        for (i in indices) {
+            val c = this[i]
+            if (i == 0 && c == '\n') continue
+            if (lineStart == ' ' || lineStart == '\t')
+                if (i == lastIndex)
+                    break
+                else {
+                    lineStart = this[i + 1]
+                    continue
+                }
+            spaces++
+            if (c == '(') parenthesis += spaces
+            else if (c == ')' && parenthesis.isNotEmpty()) parenthesis.pop()
+            else if (c == '{') parenthesis += spaces + 1 // eg: ..{ a0, a1,\nb0, b1 ->
+            aligned += c
+            if (c == '\n' && i != 0 && i != lastIndex) {
+                val nextC = this[i + 1]
+                if ((lastC == ',' || lastC == ' ') && nextC.isLetterOrDigit()) {
+                    val padding = parenthesis.lastOrNull() ?: 0
+                    aligned += " ".repeat(padding)
+                    spaces = padding
+                    lineStart = nextC
+                } else
+                    spaces = 0
+            }
+            lastC = c
+        }
+        builder.appendLine(aligned.trimIndent().prependIndent(indentation))
+        //        builder.appendLine(trimIndent().prependIndent(indentation))
+    }
+
+    operator fun String.invoke(block: () -> Unit) {
+        +"$this {"
+        indent(block)
+        +"}"
+    }
+
+    operator fun StringBuilder.plusAssign(text: String) {
+        appendLine(text)
+    }
+
+    operator fun String.times(i: Int) = (1..i).joinToString { this }
+
+    fun deleteLast() = builder.deleteAt(builder.lastIndex)
+
+    val contract = "kotlin.contracts.contract { callsInPlace(res, kotlin.contracts.InvocationKind.EXACTLY_ONCE) }"
+
+    fun contract(name: String) = "kotlin.contracts.contract { callsInPlace($name, kotlin.contracts.InvocationKind.EXACTLY_ONCE) }"
+
+    val newLineAligned: Unit
+        get() {
+            var index = builder.length
+            var spaces = 0
+            var foundParenthes = false
+            while (true) {
+                if (builder[index] == '(') {
+                    foundParenthes = true
+                    spaces++
+                }
+                if (foundParenthes && builder[index] != '\n')
+                    spaces++
+                index--
+            }
+        }
+
+    fun write(path: String) {
+        File(targetDir, "uns/$path.kt").apply {
+            parentFile.mkdirs()
+            writeText(builder.toString())
+        }
+    }
+
+    var lastDoc = ""
+    fun docs(docs: String) {
+        lastDoc = docs
+        val lines = docs.trimMargin().lines()
+        if (lines.size == 1) builder.appendLine("$indentation/** ${lines[0]} */")
+        else {
+            builder.appendLine("$indentation/**")
+            for (line in lines)
+                builder.appendLine("$indentation * $line")
+            builder.appendLine("$indentation */")
+        }
+    }
+
+    enum class Experimentals(val subPkg: String? = null) {
+        Multiplatform,
+        StdlibApi,
+        Contracts("contracts"),
+        UnsignedTypes,
+        JsExport("js"),
+        PathApi("io.path"),
+        Time("time"),
+        TypeInference("experimental");
+
+        val pkg: String
+            get() = when (subPkg) {
+                null -> "kotlin"
+                else -> "kotlin.$subPkg"
+            }
+    }
+
+    val operators = listOf("+" to "plus", "-" to "minus", "*" to "times", "/" to "div", "%" to "rem")
+    val unsafeOperators = listOf("div", "rem")
+    val bitwiseOperators = listOf("and", "or", "xor", "shl", "shr", "inv")
+    val unsafeBitwiseOperators = listOf("shr", "inv")
+
+    companion object {
+        lateinit var targetDir: File
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/uns/operators.kt b/buildSrc/src/main/kotlin/uns/operators.kt
new file mode 100644
index 0000000..3e96c65
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/operators.kt
@@ -0,0 +1,87 @@
+package uns
+
+import uns.gen.generate
+
+fun operators() {
+
+    generate("operators") {
+
+        nothingToInline = true
+
+        for (receiver in signedTypeInfos + kotlinUnsTypeInfo) {
+
+            val RecType = receiver.type
+
+            for ((sign, op) in operators) {
+
+                for (u in unsInfos) {
+
+                    val UType = u.type
+                    val base = "inline infix operator fun $RecType.$op(other: $UType): "
+                    when {
+                        receiver.isU -> when {
+                            receiver.bits <= u.bits -> +"$base$UType = $UType(this $sign other.v)"
+                            RecType == "UShort" -> +"$base$RecType = (this $sign other.v).toUShort()"
+                            else -> +"$base$RecType = this $sign other.v"
+                        }
+                        receiver.bits <= u.bits -> +"$base$UType = $UType(this.toU$RecType() $sign other.v)"
+                        RecType == "Short" -> +"$base$RecType = (this $sign other.to$RecType()).toShort()"
+                        else -> +"$base$RecType = this $sign other.to$RecType()"
+                    }
+                }
+            }
+        }
+
+        imports += "com.ionspin.kotlin.bignum.integer.toBigInteger"
+
+        for (receiver in signedTypeInfos + kotlinUnsTypeInfo) {
+
+            val RecType = receiver.type
+
+            for (op in bitwiseOperators) {
+
+                for (u in unsInfos) {
+
+                    if (op == "inv") continue
+
+                    val UType = u.type
+                    val base = "inline infix fun $RecType.$op(other: $UType): $RecType = "
+                    if (RecType == "BigInt") {
+                        val type = if (op.startsWith("sh")) "Int" else "BigInteger"
+                        +"${base}this $op other.v.to$type()"
+                    } else when (op) {
+                        "shl", "shr" -> when {
+                            receiver.isPromoted -> {
+                                val maybeToU = if (receiver.isU) "" else ".toU$RecType()"
+                                +"$base(this$maybeToU.toUInt() $op other.v.toInt()).to$RecType()"
+                            }
+                            else -> +"${base}this $op other.v.toInt()"
+                        }
+                        else -> when {
+                            receiver.isU -> {
+                                val maybeTo = if (u.counterType != RecType) ".to$RecType()" else ""
+                                +"${base}this $op other.v$maybeTo"
+                            }
+                            receiver.bits >= u.bits -> {
+                                val maybeTo = if (u.counterType == "U$RecType") "" else ".toU$RecType()"
+                                +"${base}(this.toU$RecType() $op other.v$maybeTo).to$RecType()"
+                            }
+                            else -> +"${base}(this.toU$RecType() $op other.v.toU$RecType()).to$RecType()"
+                        }
+                    }
+                }
+            }
+
+            for (u in unsInfos) {
+                if (!receiver.isU)
+                    continue
+                val UType = u.type
+                when {
+                    RecType == "BigInt" -> +"infix operator fun BigInt.compareTo(other: $UType): Int = compareTo(other.v.toBigInteger())"
+                    receiver.isU -> +"infix operator fun $RecType.compareTo(other: $UType): Int = to$RecType().compareTo(other.v)"
+                    else -> +"infix operator fun $RecType.compareTo(other: $UType): Int = toU$RecType().compareTo(other.v)"
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/uns/types.kt b/buildSrc/src/main/kotlin/uns/types.kt
new file mode 100644
index 0000000..3ebdac9
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/types.kt
@@ -0,0 +1,281 @@
+package uns
+
+import org.gradle.configurationcache.extensions.capitalized
+import uns.gen.generate
+
+fun types() {
+
+    for (typeInfo in unsInfos) {
+
+        val (Type, _) = typeInfo
+
+        generate(Type) {
+
+            for (uns in unsTypes + "BigInt")
+                if (uns != Type)
+                    imports += "uns.$uns"
+            imports += "com.ionspin.kotlin.bignum.integer.BigInteger"
+
+            val signedType = typeInfo.counterType.drop(1).lowercase()
+            val counterInfo = typeInfo.counterInfo
+            val UType = counterInfo.type
+
+            nothingToInline = true
+            for (constrInfo in intTypeInfos) {
+                if (constrInfo.isU || constrInfo.type == "BigInt")
+                    continue
+                val ConstrType = constrInfo.type
+                val constrType = ConstrType.lowercase()
+                +"inline fun $Type($constrType: $ConstrType): $Type = $Type($constrType.toU$ConstrType())"
+                //                val CounterConstrType = constrInfo.counterType
+                //                if (counterInfo.type == CounterConstrType) {
+                //                    val exactRequired = if (ConstrType == "BigInt") ", exactRequired: Boolean = true" else ""
+                //                    if (ConstrType != UType)
+                //                        +"inline fun $Type($constrType: $ConstrType$exactRequired) : this(".plus(when (ConstrType) {
+                //                                                                                                     "BigInt" -> "$constrType.u${signedType}Value(exactRequired))"
+                //                                                                                                     Type -> "$constrType.v)"
+                //                                                                                                     else -> "$constrType.to$UType())"
+                //                                                                                                 })
+                //                }
+            }
+
+            "class $Type(var v: $UType = MIN.v) : Number(), Comparable<$Type>" {
+
+                val CounterPromotedType = counterInfo.promotedType
+                val counterPromotedType = CounterPromotedType.lowercase()
+                val maybeConst = if (typeInfo.isPrimitive) "const " else ""
+
+                "companion object" {
+
+                    val (minValue, maxValue) = when (Type) {
+                        "U8" -> "0u" to "0xFFu"
+                        "U16" -> "0u" to "0xFFFFu"
+                        "U32" -> "0uL" to "0xFFFF_FFFFuL"
+                        "U64" -> "BigInteger.ZERO" to "ULong.MAX_VALUE.toBigInteger()"
+                        else -> error("invalid type $Type")
+                    }
+                    val bits = typeInfo.bits
+                    +"""
+                        /** A $counterPromotedType constant holding the minimum value an `unsigned $signedType` can have, 0. */
+                        ${maybeConst}val MIN_$counterPromotedType: $CounterPromotedType = $minValue
+                        
+                        /** A $counterPromotedType constant holding the maximum value an `unsigned $signedType` can have, 2^$bits-1. */
+                        ${maybeConst}val MAX_$counterPromotedType: $CounterPromotedType = $maxValue
+                        
+                        /** A constant holding the minimum value an `unsigned $signedType` can have, 0.  */
+                        val MIN = $Type($UType.MIN_VALUE)
+                
+                        /** A constant holding the maximum value an `unsigned $signedType` can have, 2^$bits-1. */
+                        val MAX = $Type($UType.MAX_VALUE)
+                        
+                        /** The number of bytes used to represent an instance of UByte in a binary form. */
+                        const val SIZE_BYTES: Int = $UType.SIZE_BYTES
+                        
+                        /** The number of bits used to represent an instance of UByte in a binary form. */
+                        const val SIZE_BITS: Int = $UType.SIZE_BITS"""
+                    //fun checkSigned(v: Number): Boolean = v.to$valueType() in MIN_VALUE..MAX_VALUE
+                }
+
+                for (constrInfo in intTypeInfos + kotlinUnsTypeInfo) {
+                    if (!constrInfo.isU && constrInfo.type != "BigInt")
+                        continue
+                    val ConstrType = constrInfo.type
+                    val constrType = ConstrType.lowercase()
+                    val exactRequired = if (ConstrType == "BigInt") ", exactRequired: Boolean = true" else ""
+                    if (ConstrType != UType) {
+                        val base = "constructor($constrType: $ConstrType$exactRequired) : this($constrType"
+                        when (ConstrType) {
+                            "BigInt" -> +"$base.u${signedType}Value(exactRequired))"
+                            Type -> +"$base.v)"
+                            else -> +"$base.to$UType())"
+                        }
+                    }
+                }
+
+                +"constructor(string: String, radix: Int = 10) : this(string.filter { it != '_' && it != '\\'' }.to$UType(radix))"
+
+                imports += "com.ionspin.kotlin.bignum.integer.toBigInteger"
+
+                for (intInfo in typeInfos + kotlinUnsTypeInfo) {
+
+                    val IntType = intInfo.type
+                    val maybePadding = if (IntType.lowercase() == Type.lowercase() || IntType == UType) "" else ".to$IntType()"
+                    val overrideOrInline = if (intInfo.isU || intInfo.type == "BigInt") "inline" else "override"
+                    val base = "$overrideOrInline fun to$IntType(): $IntType ="
+                    when {
+                        intInfo.isKotlinUns -> +"$base v$maybePadding"
+                        intInfo.isU -> +"$base $IntType(v)"
+                        IntType == "BigInt" -> +"$base v.toBigInteger()"
+                        else -> +"$base v.to$IntType()"
+                    }
+                }
+                +"""
+                    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+                    override fun toChar() = toInt().toChar()
+                    inline fun copy(): $Type = to$Type()
+                    inline operator fun inc(): $Type = $Type(v.inc())
+                    inline operator fun dec(): $Type = $Type(v.dec())"""
+
+                for ((sign, op) in operators) {
+                    for (arg in typeInfos + kotlinUnsTypeInfo) {
+                        val ArgType = arg.type
+                        val maybeV = if (arg.isKotlinUns) "" else ".v"
+                        val base = "infix inline operator fun $op(b: $ArgType): "
+                        when {
+                            arg.isU -> when {
+                                typeInfo.bits >= arg.bits -> +"$base$Type = $Type(v $sign b$maybeV)"
+                                else -> {
+                                    val kotlinUnsType = 'U' + ArgType.drop(1).capitalized()
+                                    val maybePromoted = if (kotlinUnsType.lowercase() == Type.lowercase()) "" else ".to$kotlinUnsType()"
+                                    if (arg.isKotlinUns)
+                                        if (arg.isPromoted)
+                                            +"$base$ArgType = (v$maybePromoted $sign b$maybeV)$maybePromoted"
+                                        else
+                                            +"$base$ArgType = v$maybePromoted $sign b$maybeV"
+                                    else {
+                                        val ArgCounterType = arg.counterType
+                                        +"$base$ArgType = $ArgType(v.to$ArgCounterType() $sign b$maybeV)"
+                                    }
+                                }
+                            }
+                            typeInfo.bits >= arg.bits -> {
+                                val maybeToUnsFirst = if (typeInfo.bits != arg.bits) ".toU$ArgType()" else ""
+                                +"$base$Type = $Type(v $sign b$maybeToUnsFirst.to$UType())"
+                            }
+                            else -> when (ArgType) {
+                                "Byte", "Short" -> +"$base$ArgType = (v.to$ArgType() $sign b).to$ArgType()"
+                                "BigInt" -> +"$base$ArgType = v.toBigInteger() $sign b"
+                                else -> +"$base$ArgType = v.to$ArgType() $sign b"
+                            }
+                        }
+                    }
+                }
+
+                for ((sign, o) in operators) {
+                    val op = o + "Assign"
+                    for (arg in typeInfos + kotlinUnsTypeInfo) {
+                        val ArgType = arg.type
+                        val maybeV = if (arg.isKotlinUns) "" else ".v"
+                        val base = "inline operator fun $op(b: $ArgType) { v "
+                        when {
+                            arg.isU -> when {
+                                typeInfo.bits >= arg.bits -> when {
+                                    typeInfo.isPromoted -> +"$base= (v $sign b$maybeV).to$UType() }"
+                                    else -> +"$base$sign= b$maybeV }"
+                                }
+                                else -> {
+                                    val kotlinUnsType = 'U' + ArgType.drop(1).capitalized()
+                                    val maybePromoted = if (kotlinUnsType.lowercase() == Type.lowercase()) "" else ".to$kotlinUnsType()"
+                                    val T = if (typeInfo.isPromoted) UType else "UInt"
+                                    if (arg.isKotlinUns)
+                                        +"$base= (v$maybePromoted $sign b).to$T() }"
+                                    else
+                                        +"$base= (v.to${arg.counterType}() $sign b$maybeV).to$T() }"
+                                }
+                            }
+                            typeInfo.bits >= arg.bits -> {
+                                val maybeToUnsFirst = if (typeInfo.bits != arg.bits) ".toU$ArgType()" else ""
+                                when {
+                                    typeInfo.isPromoted && arg.isPromoted -> +"$base= (v $sign b$maybeToUnsFirst.to$UType()).to$UType() }"
+                                    else -> +"$base$sign= b$maybeToUnsFirst.to$UType() }"
+                                }
+                            }
+                            else -> when (ArgType) {
+                                "BigInt" -> +"$base= (v.toBigInteger() $sign b).u${signedType}Value() }"
+                                "Float", "Double" -> {
+                                    val pad = when (Type) {
+                                        "U8", "U16" -> ".toInt()"
+                                        "U64" -> ".toLong()"
+                                        else -> ""
+                                    }
+                                    +"$base= (v.to$ArgType() $sign b)$pad.to$UType() }"
+                                }
+                                else -> +"$base= (v.to$ArgType() $sign b).to$UType() }"
+                            }
+                        }
+                    }
+                }
+
+                for (op in bitwiseOperators) {
+                    if (op[0] != 's')
+                        imports += "kotlin.experimental.$op"
+                    for (info in intTypeInfos + kotlinUnsTypeInfo) {
+                        val T = info.type
+                        val maybeV = if (info.isUx) ".v" else ""
+                        when (op) {
+                            "inv" -> {
+                                if (Type == T)
+                                    +"inline fun inv(): $Type = $Type(v.inv())"
+                            }
+                            "shl", "shr" -> {
+                                val maybePromote = if (typeInfo.isPromoted) ".toUInt()" else ""
+                                val maybeToInt = when (T) {
+                                    "BigInt" -> ".intValue()"
+                                    "Int" -> ""
+                                    else -> ".toInt()"
+                                }
+                                +"inline infix fun $op(b: $T): $Type = $Type(v$maybePromote $op b$maybeV$maybeToInt)"
+                            }
+                            else -> {
+                                val toType = if (T == "BigInt") "u${signedType}Value" else "to$UType"
+                                val maybeToType = if (Type == T || UType == T) "" else ".$toType()"
+                                val maybeToUnsFirst = if (typeInfo.bits != info.bits && !info.isU && T != "BigInt") ".toU$T()" else ""
+                                +"inline infix fun $op(b: $T): $Type = $Type(v $op b$maybeV$maybeToUnsFirst$maybeToType)"
+                            }
+                        }
+                    }
+                }
+                for (op in bitwiseOperators) {
+                    for (info in intTypeInfos + kotlinUnsTypeInfo) {
+                        val T = info.type
+                        val maybeV = if (info.isUx) ".v" else ""
+                        val maybeToType = when (T) {
+                            "BigInt" -> ".u${signedType}Value()"
+                            UType, Type -> ""
+                            else -> ".to$UType()"
+                        }
+                        when (op) {
+                            "inv" -> {
+                                if (Type == T)
+                                    +"inline fun invAssign() { v = v.inv() }"
+                            }
+                            "shl", "shr" -> {
+                                val maybeToInt = when (T) {
+                                    "Int" -> ""
+                                    "BigInt" -> ".intValue()"
+                                    else -> ".toInt()"
+                                }
+                                if (typeInfo.isPromoted)
+                                    +"inline infix fun ${op}Assign(b: $T) { v = (v.toUInt() $op b$maybeToInt).to$UType() }"
+                                else
+                                    +"inline infix fun ${op}Assign(b: $T) { v = v $op b${maybeV}$maybeToInt }"
+                            }
+                            else -> +"inline infix fun ${op}Assign(b: $T) { v = v $op b${maybeV}$maybeToType }"
+                        }
+                    }
+                }
+
+                imports += "uns.format.format"
+                for (cmp in unsTypeInfo) {
+                    //                    if ()
+                    val CmpType = cmp.type
+                    val overrideOrInline = if (Type == CmpType) " override" else " inline"
+                    val base = "infix$overrideOrInline operator fun compareTo(other: $CmpType): Int = "
+                    val receiver = when {
+                        Type == CmpType || UType == CmpType -> "v"
+                        cmp.isUx -> "to${cmp.counterType}()"
+                        else -> "to$CmpType()"
+                    }
+                    val maybeV = if (Type == CmpType || cmp.isUx) ".v" else ""
+                    +"$base$receiver.compareTo(other$maybeV)"
+                }
+                +"""
+                    override fun equals(other: Any?): Boolean = other is $Type && v == other.v
+                    override fun hashCode(): Int = v.hashCode()
+                    override fun toString(): String = v.toString()
+                    inline fun toString(radix: Int): String = v.toString(radix)
+                    inline fun toString(format: String): String = format.format(this)"""
+            }
+        }
+    }
+}
diff --git a/buildSrc/src/main/kotlin/uns/util.kt b/buildSrc/src/main/kotlin/uns/util.kt
new file mode 100644
index 0000000..c8a1f3f
--- /dev/null
+++ b/buildSrc/src/main/kotlin/uns/util.kt
@@ -0,0 +1,97 @@
+package uns
+
+val intTypeInfos = listOf(TypeInfo("Byte", "i8"),
+                          TypeInfo("Short", "i16"),
+                          TypeInfo("Int", "i32"),
+                          TypeInfo("Long", "i64"),
+                          TypeInfo("U8", "u8"),
+                          TypeInfo("U16", "u16"),
+                          TypeInfo("U32", "u32"),
+                          TypeInfo("U64", "u64"),
+                          TypeInfo("BigInt", "bigInt"))
+val signedTypeInfos = intTypeInfos.filter { !it.isU }
+val typeInfos = intTypeInfos + TypeInfo("Float", "f") + TypeInfo("Double", "d")
+val kotlinUnsTypeInfo = listOf(TypeInfo("UByte"), TypeInfo("UShort"), TypeInfo("UInt"), TypeInfo("ULong"))
+val unsTypeInfo = intTypeInfos.filter { it.isU } + kotlinUnsTypeInfo
+val floatingTypes = listOf(TypeInfo("Float", "f32"), TypeInfo("Double", "f64"))
+val extensionsToInformation = intTypeInfos.associateBy { it.extension }
+val typeToInformation = intTypeInfos.associateBy { it.type }
+val intPromotedTypes = listOf("Byte", "Short", "UByte", "UShort")
+val intTypes = intTypeInfos.map { it.type }
+val unsInfos = intTypeInfos.filter { it.type[0] == 'U' }
+val unsTypes = unsInfos.map { it.type }
+
+data class TypeInfo(val type: String, val extension: String = type.take(2).lowercase()) {
+
+    val isU
+        get() = type[0] == 'U'
+    val isKotlinUns
+        get() = isU && type[1].isUpperCase()
+
+    val isUx
+        get() = isU && !isKotlinUns
+    val bits: Int
+        get() = when (type) {
+            "UByte", "Byte", "U8", "I8" -> 8
+            "UShort", "Short", "U16", "I16" -> 16
+            "UInt", "Int", "U32", "I32" -> 32
+            "ULong", "Long", "U64", "I64" -> 64
+            else -> 65 // BigInteger
+        }
+
+    val isPromoted: Boolean
+        get() = when(type) {
+            "U8", "Byte", "UByte", "U16", "Short", "UShort" -> true
+            else -> false
+        }
+
+    val counterType: String
+        get() = counterInfo.type
+    val counterInfo: TypeInfo
+        get() = (intTypeInfos + kotlinUnsTypeInfo).first {
+            it.type == when (type) {
+                "U8" -> "UByte"
+                "U16" -> "UShort"
+                "U32" -> "UInt"
+                "U64" -> "ULong"
+                "I8" -> "Byte"
+                "I16" -> "Short"
+                "I32" -> "Int"
+                "I64" -> "Long"
+                "UByte" -> "Byte"
+                "UShort" -> "Short"
+                "UInt" -> "Int"
+                "ULong" -> "Long"
+                else -> error("invalid type: `$type`")
+            }
+        }
+
+    val promotedType: String
+        get() = promotedInfo.type
+    val promotedInfo: TypeInfo
+        get() = (intTypeInfos + kotlinUnsTypeInfo).first {
+            it.type == when (type) {
+                "U8", "U16" -> "U32"
+                "I8", "I16" -> "I32"
+                "UByte", "UShort" -> "UInt"
+                "U32" -> "U64"
+                "I32" -> "I64"
+                "UInt" -> "ULong"
+                "U64", "I64", "ULong" -> "BigInt"
+                else -> error("invalid type: `$type`")
+            }
+        }
+
+    val isPrimitive: Boolean
+        get() = when (type) {
+            "I8", "I16", "I32", "I64", "UByte", "UShort", "UInt", "ULong" -> true
+            else -> false
+        }
+
+//    val paddedType: String
+//        get() = when(type) {
+//            "Ubyte", "Ushort" ->
+//        }
+}
+
+operator fun Iterable<TypeInfo>.minus(types: Iterable<String>) = types.toSet().let { typeSet -> this.filter { it.type !in typeSet } }
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index d222ac9..3bafa98 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,7 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
-distributionSha256Sum=591855b517fc635b9e04de1d05d5e76ada3f89f5fc76f87978d1b245b4f69225
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionSha256Sum=3e1af3ae886920c3ac87f7a91f816c0c7c436f276a6eefdb3da152100fef72ae
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/jitpack.yml b/jitpack.yml
deleted file mode 100644
index 4938d8a..0000000
--- a/jitpack.yml
+++ /dev/null
@@ -1,6 +0,0 @@
-jdk:
-  - openjdk11
-
-install:
-  - echo "Running a custom install command"
-  - ./gradlew clean assemble -x dokkaHtml -x dokkaHtmlJar -x javadoc -x dokkaJavadocJar publishToMavenLocal -xtest
\ No newline at end of file
diff --git a/settings.gradle.kts b/settings.gradle.kts
index f82ace5..fd3d7fe 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -10,7 +10,7 @@ pluginManagement {
 
 gradle.rootProject {
     group = "kotlin.graphics"
-    version = "3.3.33"
+    version = "3.4.0"
 }
 
 //includeBuild("../magik")
\ No newline at end of file
diff --git a/src/commonMain/kotlin/uns/BigInt.kt b/src/commonMain/kotlin/uns/BigInt.kt
new file mode 100644
index 0000000..1a084dc
--- /dev/null
+++ b/src/commonMain/kotlin/uns/BigInt.kt
@@ -0,0 +1,10 @@
+/**
+ * Created by GBarbieri on 03.02.2017.
+ */
+
+package uns
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+
+
+//inline fun BigInt(byte: Byte): BigInt = BigInteger.fromByte(byte)
\ No newline at end of file
diff --git a/src/commonMain/kotlin/uns/aliases.kt b/src/commonMain/kotlin/uns/aliases.kt
new file mode 100644
index 0000000..2487739
--- /dev/null
+++ b/src/commonMain/kotlin/uns/aliases.kt
@@ -0,0 +1,12 @@
+package uns
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+
+
+typealias I8 = Byte
+typealias I16 = Short
+typealias I32 = Int
+typealias I64 = Long
+typealias F32 = Float
+typealias F64 = Double
+typealias BigInt = BigInteger
\ No newline at end of file
diff --git a/src/commonMain/kotlin/uns/format/ExponentFormatter.kt b/src/commonMain/kotlin/uns/format/ExponentFormatter.kt
new file mode 100644
index 0000000..8d3eb71
--- /dev/null
+++ b/src/commonMain/kotlin/uns/format/ExponentFormatter.kt
@@ -0,0 +1,157 @@
+package uns.format
+
+import kotlin.math.*
+
+class ExponentFormatter(val value: Double) {
+
+    var mantissa: Double
+        private set
+    var exponent: Int = 0
+        private set(value) {
+            field = value
+            strExponent = "e$exponent"
+        }
+
+    private val mstr: String
+    private var strExponent: String
+
+    init {
+        val x = abs(value)
+        exponent = log10(x).toInt()
+        if (exponent < 0) exponent--
+        mantissa = x / 10.0.pow(exponent)
+        if (value < 0) mantissa = -mantissa
+        mstr = mantissa.toString()
+        strExponent = "e$exponent"
+    }
+
+    fun scientific(width: Int, fractionWidth: Int = -1): String {
+        val minLength = if (mantissa < 0) 2 else 1
+
+        // Get the desired part of mantissa with proper bounding and rounding
+        // it works only for "normalized" mantissa that is always has d[.ddddd] form, e.g.  integer
+        // part is always 1 digit long
+        //
+        // ERROR: this rounding does not work with trailint (***9)8 - like variants
+        //
+        fun mpart(length: Int): String {
+            var l = length
+            if (l > mstr.length) l = mstr.length
+            val result = StringBuilder(mstr.slice(0 until l))
+            if (result.length == mstr.length)
+            // exact value, no rounding:
+                return result.toString()
+
+            // last visible digit index
+//            var lastIndex = result.length - 1
+//            if (result[lastIndex] == '.') lastIndex--
+
+            // next significant digit
+            var nextDigit = mstr[result.length]
+            if (nextDigit == '.') {
+                if (result.length + 1 >= mstr.length)
+                    return result.toString()
+                nextDigit = mstr[result.length + 1]
+            }
+            if (nextDigit in "56789") {
+                val (m, ovf) = roundUp(result)
+                if (!ovf) return m
+                // overflow: exponent should grow
+                exponent++
+                // and the point position should be fixed
+                val pointPos = m.indexOf('.')
+                val mb = StringBuilder(m)
+                if (pointPos == -1)
+                    return m // it was the last letter and was tehrefore removed by roundUp
+                return mb.deleteAt(pointPos).insert(pointPos - 1, '.').toString()
+            }
+            return result.toString()
+        }
+
+//        val mantissa = mstr.toDouble()
+
+
+        if (width == 0) return mstr + strExponent
+
+        if (fractionWidth < 0 && width > 0) {
+            var l = width - strExponent.length
+            if (l < minLength) l = minLength
+            return mpart(l) + strExponent
+        }
+
+        if (fractionWidth < 0 && width < 0) {
+            return mstr + strExponent
+        }
+
+        // fractionWidth >= 0
+        if (fractionWidth == 0) return "${mstr[0]}$strExponent"
+
+        // fractionWitdth > 0, +1 for decimal dot
+        return mpart(minLength + 1 + fractionWidth) + strExponent
+    }
+
+
+    override fun toString(): String = "${mantissa}e${exponent}"
+
+}
+
+internal fun scientificFormat(value: Double, width: Int, fractionPartLength: Int = -1): String =
+    ExponentFormatter(value).scientific(width, fractionPartLength)
+
+internal fun fractionalFormat(_value: Double, width: Int, fractionPartLength: Int = -1): String {
+    var value = _value
+    val result = StringBuilder()
+
+    if (abs(value) >= 1) {
+        val i = if (fractionPartLength == 0) value.roundToLong() else value.toLong()
+        result.append(i)
+        result.append('.')
+        value -= i
+    } else
+        result.append((if (value < 0) "-0." else "0."))
+
+    var fl = if (fractionPartLength < 0) {
+        if (width < 0) 6
+        else width - result.length
+    } else fractionPartLength
+
+    var rest = value * 10
+    while (fl-- > 0) {
+        val d = rest.toInt()
+        result.append(abs(d))
+        rest = (rest - d) * 10
+    }
+    // now we might need to round it up:
+    return if (rest.toInt().absoluteValue < 5) result.toString() else roundUp(result, keepWidth = false).first
+}
+
+/**
+ * Round up the mantissa part (call it with default arguments to start).
+ * @return rounded mantissa and overflow flag (set when 9,99 -> 10,00 and like)
+ */
+private fun roundUp(result: StringBuilder,
+                    length: Int = result.length,
+                    pos: Int = result.length - 1,
+                    keepWidth: Boolean = true): Pair<String, Boolean> {
+    if (pos < 0) {
+        // if we get there, it means the number of digits should grow, like "9.99" -> "10.00"
+        // but we need to keep the length so "10.0":
+        result.insert(0, '1')
+        if (keepWidth) result.deleteAt(length)
+        return result.toString() to true
+    }
+    // not the first digit: perform rounding:
+    val d = result[pos]
+    // it could be a decimal point we ignore and continue with rounding
+    if (d == '.') return roundUp(result, length, pos - 1, keepWidth)
+
+    // Small number add one "0.19" -> "0.2"
+    // Simple case: alter only the current digit
+    if (d != '9') {
+        result[pos] = d + 1
+        return result.toString() to false
+    }
+    // Complex case:  9->0 and propogate changes up.
+    result[pos] = '0'
+    return roundUp(result, length, pos - 1, keepWidth)
+}
\ No newline at end of file
diff --git a/src/commonMain/kotlin/uns/format/Specification.kt b/src/commonMain/kotlin/uns/format/Specification.kt
new file mode 100644
index 0000000..fd8c355
--- /dev/null
+++ b/src/commonMain/kotlin/uns/format/Specification.kt
@@ -0,0 +1,317 @@
+package uns.format
+
+//import kotlinx.datetime.*
+
+internal enum class Positioning {
+    LEFT, RIGHT, CENTER
+}
+
+internal class Specification(val parent: Sprintf, var index: Int) {
+
+    enum class Stage {
+        FLAGS,
+        LENGTH,
+        FRACTION
+    }
+
+    private var stage = Stage.FLAGS
+
+    private var size: Int = -1
+    private var fractionalPartSize: Int = -1
+    private var positioninig = Positioning.RIGHT
+    private var fillChar = ' '
+    private var currentPart = StringBuilder()
+
+    //    private var pos = 0
+    private var explicitPlus = false
+    private var done = false
+    private var indexIsOverriden = false
+
+    private val isScanningFlags: Boolean
+        get() = stage == Stage.FLAGS
+
+    internal fun scan() {
+        while (!done) {
+            val ch = parent.nextChar()
+//            println("spec: $ch: $stage [$currentPart]")
+            when (ch) {
+                '-', '^' -> {
+                    if (!isScanningFlags) invalidFormat("unexpected $ch")
+                    positioninig = if (ch == '-') Positioning.LEFT else Positioning.CENTER
+                }
+                '+' -> {
+                    if (!isScanningFlags) invalidFormat("unexpected $ch")
+                    explicitPlus = true
+                }
+                in "*#_=" -> {
+                    if (!isScanningFlags) invalidFormat("bad fill char $ch position")
+                    fillChar = ch
+                }
+                '0' -> {
+                    if (isScanningFlags) fillChar = '0'
+                    else
+                        currentPart.append(ch)
+                }
+                in "123456789" -> {
+                    if (stage == Stage.FLAGS) stage = Stage.LENGTH
+                    currentPart.append(ch)
+                }
+                '$', '!' -> {
+                    if (stage != Stage.LENGTH) invalidFormat("unexpected $ch position")
+                    if (indexIsOverriden) invalidFormat("argument number '$ch' should occur only once")
+                    indexIsOverriden = true
+                    index = currentPart.toString().toInt() - 1
+                    parent.pushbackArgumentIndex()
+                    currentPart.clear()
+                }
+                's' -> createStringField()
+                'd', 'i' -> createIntegerField()
+                'o' -> createOctalField()
+                'x' -> createHexField(false)
+                'X' -> createHexField(true)
+                'f', 'F' -> createFloat()
+                'E' -> createScientific(true)
+                'e' -> createScientific(false)
+                'g' -> createAutoFloat(true)
+                'G' -> createAutoFloat(false)
+                'c', 'C' -> createCharacter()
+//                't' -> createTimeField(false)
+//                'T' -> createTimeField(true)
+                '.' -> stage = when (stage) {
+                    Stage.FLAGS -> Stage.FRACTION
+                    Stage.LENGTH -> {
+                        endStage(false)
+                        Stage.FRACTION
+                    }
+                    else -> invalidFormat("can't parse specification: unexpected '.'")
+                }
+                else -> invalidFormat("unexpected character '$ch'")
+            }
+        }
+    }
+
+    private fun invalidFormat(message: String): Nothing = parent.invalidFormat(message)
+
+//    private val time: LocalDateTime
+//        get() = parent.getLocalDateTime(index)
+
+//    private fun createTimeField(upperCase: Boolean) {
+//        val ch = parent.nextChar()
+//        endStage()
+//        val result: String = when (ch) {
+//            'H' -> "%02d".sprintf(time.hour)
+//            'k' -> "%d".sprintf(time.hour)
+//            'I', 'l' -> {
+//                var t = time.hour
+//                if (t > 12) t -= 12
+//                if (ch == 'I') "%02d".sprintf(t)
+//                else t.toString()
+//            }
+//            'M' -> "%02d".sprintf(time.minute)
+//            'S' -> "%02d".sprintf(time.second)
+//            'L' -> "%03d".sprintf(time.nanosecond / 1_000_000)
+//            'N' -> "%09d".sprintf(time.nanosecond)
+//            'p' -> when {
+//                upperCase -> if (time.hour > 12) "PM" else "AM"
+//                time.hour > 12 -> "pm"
+//                else -> "am"
+//            }
+//            'z' -> {
+//                val tz = TimeZone.currentSystemDefault()
+//                tz.offsetAt(time.toInstant(tz)).toString().replace(":", "")
+//            }
+//            'Z' -> {
+//                // There us yet no abbreviations like 'CET', so we put there string representation like +01:00
+//                val tz = TimeZone.currentSystemDefault()
+//                tz.offsetAt(time.toInstant(tz)).toString()
+//            }
+//            's' -> {
+//                val tz = TimeZone.currentSystemDefault()
+//                time.toInstant(tz).epochSeconds.toString()
+//            }
+//            'Q' -> {
+//                val tz = TimeZone.currentSystemDefault()
+//                time.toInstant(tz).toEpochMilliseconds().toString()
+//            }
+//            // Date fields
+//            'B' -> getMonthName(time.month.number)
+//            'b', 'h' -> getAbbreviatedMonthName(time.month.number)
+//            'e' -> time.dayOfMonth.toString()
+//            'd' -> "%02s".sprintf(time.dayOfMonth)
+//            'm' -> "%02s".sprintf(time.month.number)
+//            'A' -> getWeekDayName(time.dayOfWeek)
+//            'a' -> getAbbreviatedWeekDayName(time.dayOfWeek)
+//            'y' -> time.year.toString().takeLast(2)
+//            'Y' -> "%04d".sprintf(time.year)
+//            'j' -> "%03d".sprintf(time.dayOfYear)
+//            // shortcuts
+//            'R' -> "%1!tH:%1!tM".sprintf(time)
+//            'r' ->
+//                if (upperCase)
+//                    "%1!tI:%1!tM:%1!tS %1!Tp".sprintf(time)
+//                else
+//                    "%1!tI:%1!tM:%1!tS %1!tp".sprintf(time)
+//            'T' -> "%tH:%1!tM:%1!tS".sprintf(time)
+//            'D' -> "%tm/%1!td/%1!ty".sprintf(time)
+//            'F' -> "%tY-%1!tm-%1!td".sprintf(time)
+//            'c' -> "%ta %1!tb %1!td %1!tT %1!tZ %1!tY".sprintf(time)
+//            'O' -> {
+//                val tz = TimeZone.currentSystemDefault()
+//                val offset = tz.offsetAt(time.toInstant(tz)).toString()
+//                "%tFT%1!tT%s".sprintf(time, offset)
+//            }
+//            '#' -> {
+//                "%tY%1!tm%1!td%1!tH%1!tM%1!tS".sprintf(time.toInstant(TimeZone.UTC))
+//            }
+//            else -> invalidFormat("unknown time field specificator: 't$ch'")
+//        }
+//        insertField(result)
+//    }
+
+    private fun createStringField() {
+        endStage()
+        insertField(parent.getText(index))
+    }
+
+    private fun createIntegerField() {
+        endStage()
+        val number = parent.getNumber(index).toLong()
+        if (explicitPlus && fillChar == '0' && number > 0)
+            insertField(number.toString(), "+")
+        else
+            insertField(if (explicitPlus) "+$number" else "$number")
+    }
+
+    private fun createHexField(upperCase: Boolean) {
+        endStage()
+        if (explicitPlus) invalidFormat("'+' is incompatible with hex format")
+        val text = when {
+            parent.isNumber(index) -> parent.getNumber(index).toLong().toString(16)
+            else -> parent.getBigInt(index).toString(16)
+        }
+        insertField(if (upperCase) text.uppercase() else text.lowercase())
+    }
+
+    private fun createOctalField() {
+        endStage()
+        val number = parent.getNumber(index).toLong()
+        if (explicitPlus) invalidFormat("'+' is incompatible with oct format")
+        insertField(number.toString(8))
+    }
+
+    private fun createCharacter() {
+        endStage()
+        insertField(parent.getCharacter(index).toString())
+    }
+
+    private fun endStage(setDone: Boolean = true) {
+        if (setDone) done = true
+        if (currentPart.isNotEmpty()) {
+            when (stage) {
+                Stage.LENGTH -> size = currentPart.toString().toInt()
+                Stage.FRACTION -> fractionalPartSize = currentPart.toString().toInt()
+                Stage.FLAGS -> invalidFormat("can't parse format specifier (error 7)")
+            }
+            currentPart.clear()
+        }
+    }
+
+    private fun insertField(text: String, prefix: String = "") {
+        val l = text.length + prefix.length
+        if (size < 0 || size < l) {
+            parent.specificationDone(prefix + text)
+        } else {
+            var padStart = 0
+            var padEnd = 0
+            when (positioninig) {
+                Positioning.LEFT -> padEnd = size - l
+                Positioning.RIGHT -> padStart = size - l
+                Positioning.CENTER -> {
+                    padStart = (size - l) / 2
+                    padEnd = size - padStart - l
+
+                }
+            }
+            val result = StringBuilder(prefix)
+            while (padStart-- > 0) result.append(fillChar)
+            result.append(text)
+            while (padEnd-- > 0) result.append(fillChar)
+            parent.specificationDone(result.toString())
+        }
+    }
+
+    private fun createFloat() {
+        endStage()
+        val number = parent.getNumber(index).toDouble()
+        val t = fractionalFormat(number, size, fractionalPartSize)
+
+        if (explicitPlus && fillChar == '0' && number > 0)
+            insertField(t, "+")
+        else
+            insertField(if (explicitPlus) "+$t" else t)
+    }
+
+    private fun createScientific(upperCase: Boolean) {
+        endStage()
+        val number = parent.getNumber(index).toDouble()
+        val t = scientificFormat(number, size, fractionalPartSize).let {
+            if (upperCase) it.uppercase() else it.lowercase()
+        }
+
+        if (explicitPlus && fillChar == '0' && number > 0)
+            insertField(t, "+")
+        else
+            insertField(if (explicitPlus) "+$t" else t)
+    }
+
+    private fun createAutoFloat(upperCase: Boolean) {
+        endStage()
+        val number = parent.getNumber(index)
+        val t = number.toString().let {
+            if (upperCase) it.uppercase() else it.lowercase()
+        }
+
+        if (explicitPlus && fillChar == '0' && number.toDouble() > 0)
+            insertField(t, "+")
+        else
+            insertField(if (explicitPlus) "+$t" else t)
+    }
+
+    companion object {
+        val englishMonthNames: List<String> by lazy {
+            "January February March April May June July August September October November December".split(
+                ' '
+            )
+        }
+        val englishWeekDayNames: List<String> by lazy {
+            "Monday Tuesday Wednesday Thursday Friday Saturday Sunday".split(' ')
+        }
+
+//        fun getAbbreviatedMonthName(monthNumber: Int) =
+//            LocaleSpecificAbbreviatedMonthName(monthNumber) ?: getMonthName(monthNumber).take(3)
+//
+//        fun getMonthName(monthNumber: Int) = LocaleSpecificMonthName(monthNumber) ?: englishMonthNames[monthNumber - 1]
+//
+//        fun getWeekDayName(d: DayOfWeek): String {
+//            val n = d.isoDayNumber
+//            return LocaleSpecificDayName(n) ?: englishWeekDayNames[n - 1]
+//        }
+//
+//        fun getAbbreviatedWeekDayName(d: DayOfWeek): String {
+//            val n = d.isoDayNumber
+//            return LocaleSpecificAbbreviatedDayName(n) ?: englishWeekDayNames[n - 1].take(3)
+//        }
+    }
+}
+
+/**
+ * Platform could provide current locale based month name or return null to use English. Month number is 1..12
+ * as default in date operations in java
+ */
+//expect fun LocaleSpecificMonthName(monthNumber: Int): String?
+//
+//expect fun LocaleSpecificAbbreviatedMonthName(monthNumber: Int): String?
+//
+//expect fun LocaleSpecificDayName(isoDayNumber: Int): String?
+//
+//expect fun LocaleSpecificAbbreviatedDayName(isoDayNumber: Int): String?
\ No newline at end of file
diff --git a/src/commonMain/kotlin/uns/format/Sprintf.kt b/src/commonMain/kotlin/uns/format/Sprintf.kt
new file mode 100644
index 0000000..e5aee5e
--- /dev/null
+++ b/src/commonMain/kotlin/uns/format/Sprintf.kt
@@ -0,0 +1,105 @@
+package uns.format
+
+//import kotlinx.datetime.*
+import uns.BigInt
+import uns.bigInt
+
+internal class Sprintf(val format: String, val args: Array<out Any?>) {
+
+    private var pos = 0
+    private var specStart = -1
+    private val result = StringBuilder()
+    private var currentIndex = 0
+
+    fun process(): Sprintf {
+        while (pos < format.length) {
+            val ch = format[pos++]
+//            println("$ch $pos $specStart [$result]")
+            if (ch == '%')
+                specStart = when {
+                    specStart == pos - 1 -> {
+                        result.append(ch)
+                        -1
+                    }
+                    specStart < 0 -> pos
+                    else -> invalidFormat("unexpected %")
+                }
+            else
+                if (specStart >= 0) {
+                    pos--
+                    Specification(this, currentIndex++).scan()
+                } else result.append(ch)
+        }
+        return this
+    }
+
+    internal fun nextChar(): Char {
+        if (pos >= format.length) invalidFormat("unexpected end of string inside format specification")
+        return format[pos++]
+    }
+
+    internal fun invalidFormat(reason: String): Nothing = throw IllegalArgumentException("bad format: $reason at ofset ${pos - 1} of \"$format\"")
+
+    override fun toString(): String = result.toString()
+
+    internal fun isNumber(index: Int): Boolean = args[index] is Number
+    internal fun getNumber(index: Int): Number = notNullArg(index)
+    internal fun getBigInt(index: Int): BigInt = when (val arg = args[index]!!) {
+        is BigInt -> arg
+        is UByte -> arg.bigInt
+        is UShort -> arg.bigInt
+        is UInt -> arg.bigInt
+        is ULong -> arg.bigInt
+        else -> error("")
+    }
+
+    internal fun getText(index: Int): String = args[index]!!.toString()
+
+    internal fun getCharacter(index: Int): Char = notNullArg(index)
+
+    internal fun specificationDone(text: String) {
+        result.append(text)
+        specStart = -1
+    }
+
+//    fun getLocalDateTime(index: Int): LocalDateTime = when (val t = notNullArg<Any>(index)) {
+//        is Instant -> t.toLocalDateTime(TimeZone.currentSystemDefault())
+//        is LocalDateTime -> t
+//        is LocalDate -> t.atTime(0, 0, 0)
+//        else -> ConvertToInstant(t).toLocalDateTime(TimeZone.currentSystemDefault())"
+//    }
+
+    @Suppress("UNCHECKED_CAST")
+    fun <T> notNullArg(index: Int): T = args[index]!! as T
+
+    fun pushbackArgumentIndex() {
+        currentIndex--
+    }
+}
+
+/**
+ * Old good C-sprintf. See formats table in the
+ * [readme](https://github.com/sergeych/mp_stools/blob/263cfc50f23cfde815928c7bdb748857fdaad2b0/README.md#L56-L56)
+ */
+fun String.sprintf(vararg args: Any?): String = Sprintf(this, args).process().toString()
+
+/**
+ * Old good C-printf. See formats table in readme. Just like C version it does not insert \n. See also
+ * [sprintf]
+ */
+fun printf(format: String, vararg args: Any?) {
+    print(Sprintf(format, args).process().toString())
+}
+
+/**
+ * Like old good C printf but also adds new line (via println). See [sprintf]
+ */
+@Suppress("unused")
+fun printlnf(format: String, vararg args: Any?) {
+    println(Sprintf(format, args).process().toString())
+}
+
+
+fun String.format(vararg args: Any?): String = Sprintf(this, args).process().toString()
+
+//expect fun ConvertToInstant(t: Any): Instant
\ No newline at end of file
diff --git a/src/commonMain/kotlin/unsigned/Byte.kt b/src/commonMain/kotlin/unsigned/Byte.kt
new file mode 100644
index 0000000..fbab696
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Byte.kt
@@ -0,0 +1,105 @@
+/**
+ * Created by elect on 19/01/2017.
+ */
+
+package unsigned
+
+//import com.ionspin.kotlin.bignum.integer.BigInteger
+//import kotlin.experimental.and
+//import kotlin.experimental.or
+//import kotlin.experimental.xor
+//
+//
+//inline fun Byte.toUbyte(): Ubyte = Ubyte(this)
+//fun Byte.toUshort(): Ushort = Ushort(this)
+//fun Byte.toUint(): Uint = Uint(this)
+//fun Byte.toUlong(): Ulong = Ulong(this)
+//
+//fun Byte.toBigInt(): BigInteger = BigInteger.fromLong(toLong())
+//fun Byte.toUBigInt(): BigInteger = BigInteger.fromULong(toULong())
+//
+//val Byte.ub: Ubyte
+//    get() = toUbyte()
+//val Byte.ui: Uint
+//    get() = toUint()
+//val Byte.ul: Ulong
+//    get() = toUlong()
+//val Byte.us: Ushort
+//    get() = toUshort()
+//
+infix fun Byte.udiv(b: Byte): Byte = toUByte().div(b.toUByte()).toByte()
+infix fun Byte.urem(b: Byte): Byte = toUByte().rem(b.toUByte()).toByte()
+infix fun Byte.ucmp(b: Byte): Int = toUByte().compareTo(b.toUByte())
+infix fun Byte.ushr(b: Byte): Byte = toUByte().toUInt().shr(b.toInt()).toByte()
+//
+//infix fun Byte.udiv(b: Short): Byte = toUByte().div(b.toUByte()).toByte()
+//infix fun Byte.urem(b: Short): Byte = toUByte().rem(b.toUByte()).toByte()
+//infix fun Byte.ucmp(b: Short): Int = toUInt().compareTo(b.toUInt())
+//infix fun Byte.ushr(b: Short): Byte = (toUInt() shr b.toInt()).toByte()
+//
+//infix fun Byte.udiv(b: Int): Byte = (toULong() / b.toULong()).toByte()
+//infix fun Byte.urem(b: Int): Byte = (toULong() % b.toULong()).toByte()
+//infix fun Byte.ucmp(b: Int): Int = toULong().compareTo(b.toULong())
+//infix fun Byte.ushr(b: Int): Byte = (toUInt() shr b).toByte()
+//
+//infix fun Byte.udiv(b: Long): Byte = (toBigInt() / b.toBigInt()).byteValue()
+//infix fun Byte.urem(b: Long): Byte = (toBigInt() % b.toBigInt()).byteValue()
+//infix fun Byte.ucmp(b: Long): Int = toBigInt().compareTo(b.toBigInt())
+//// no Byte ushr Long
+//
+//
+//operator fun Byte.plus(b: Ubyte): Byte = (this + b.v).toByte()
+//operator fun Byte.minus(b: Ubyte): Byte = (this - b.v).toByte()
+//operator fun Byte.times(b: Ubyte): Byte = (this * b.v).toByte()
+//infix fun Byte.and(b: Ubyte): Byte = this and b.v
+//infix fun Byte.or(b: Ubyte): Byte = this or b.v
+//infix fun Byte.xor(b: Ubyte): Byte = this xor b.v
+//infix fun Byte.shl(b: Ubyte): Byte = (toInt() shl b.toInt()).toByte()
+//
+//infix fun Byte.udiv(b: Ubyte): Byte = (toUInt() / b.v.toUInt()).toByte()
+//infix fun Byte.urem(b: Ubyte): Byte = (toUInt() % b.v.toUInt()).toByte()
+//infix fun Byte.ucmp(b: Ubyte): Int = toUInt().compareTo(b.v.toUInt())
+//infix fun Byte.ushr(b: Ubyte): Byte = (toUInt() shr b.toInt()).toByte()
+//
+//
+//operator fun Byte.plus(b: Ushort): Byte = (this + b.v).toByte()
+//operator fun Byte.minus(b: Ushort): Byte = (this - b.v).toByte()
+//operator fun Byte.times(b: Ushort): Byte = (this * b.v).toByte()
+//infix fun Byte.and(b: Ushort): Byte = this and b.toByte()
+//infix fun Byte.or(b: Ushort): Byte = this or b.toByte()
+//infix fun Byte.xor(b: Ushort): Byte = this xor b.toByte()
+//infix fun Byte.shl(b: Ushort): Byte = (toInt() shl b.v.toInt()).toByte()
+//
+//infix fun Byte.udiv(b: Ushort): Byte = (toUInt() / b.toInt()).toByte()
+//infix fun Byte.urem(b: Ushort): Byte = (toUInt() % b.toInt()).toByte()
+//infix fun Byte.ucmp(b: Ushort): Int = toUInt().compareTo(b.toInt())
+//infix fun Byte.ushr(b: Ushort): Byte = (toUInt() shr b.v.toInt()).toByte()
+//
+//
+//operator fun Byte.plus(b: Uint) = (this + b.v).toByte()
+//operator fun Byte.minus(b: Uint) = (this - b.v).toByte()
+//operator fun Byte.times(b: Uint) = (this * b.v).toByte()
+//infix fun Byte.and(b: Uint) = this and b.toByte()
+//infix fun Byte.or(b: Uint) = this or b.toByte()
+//infix fun Byte.xor(b: Uint) = this xor b.toByte()
+//infix fun Byte.shl(b: Uint) = (toInt() shl b.v).toByte()
+//
+//infix fun Byte.udiv(b: Uint) = (toULong() / b.toLong()).toByte()
+//infix fun Byte.urem(b: Uint) = (toULong() % b.toLong()).toByte()
+//infix fun Byte.ucmp(b: Uint) = toULong().compareTo(b.toLong())
+//infix fun Byte.ushr(b: Uint) = (toUInt() ushr b.toInt()).toByte()
+//
+//
+//operator fun Byte.plus(b: Ulong) = (this + b.v).toByte()
+//operator fun Byte.minus(b: Ulong) = (this - b.v).toByte()
+//operator fun Byte.times(b: Ulong) = (this * b.v).toByte()
+//infix fun Byte.and(b: Ulong) = this and b.toByte()
+//infix fun Byte.or(b: Ulong) = this or b.toByte()
+//infix fun Byte.xor(b: Ulong) = this xor b.toByte()
+//infix fun Byte.shl(b: Ulong) = (toInt() shl b.toInt()).toByte()
+//
+//infix fun Byte.udiv(b: Ulong) = (toULong() / b.toLong()).toByte()
+//infix fun Byte.urem(b: Ulong) = (toULong() % b.toLong()).toByte()
+//infix fun Byte.ucmp(b: Ulong) = toULong().compareTo(b.toLong())
+//// no Byte ushr Ulong
+//
diff --git a/src/commonMain/kotlin/unsigned/Int.kt b/src/commonMain/kotlin/unsigned/Int.kt
new file mode 100644
index 0000000..2b7c796
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Int.kt
@@ -0,0 +1,118 @@
+/**
+ * Created by GBarbieri on 30.01.2017.
+ */
+
+package unsigned
+
+//import com.ionspin.kotlin.bignum.integer.BigInteger
+//
+//
+//fun Int.toUbyte(): Ubyte = Ubyte(this)
+//fun Int.toUshort(): Ushort = Ushort(this)
+//fun Int.toUint(): Uint = Uint(this)
+//fun Int.toUlong(): Ulong = Ulong(toLong())
+//
+//fun Int.toBigInt(): BigInteger = BigInteger.fromLong(toLong())
+//fun Int.toUBigInt(): BigInteger = BigInteger.fromULong(toULong())
+//
+//val Int.ub
+//    get() = toUbyte()
+//val Int.ui
+//    get() = toUint()
+//val Int.ul
+//    get() = toUlong()
+//val Int.us
+//    get() = toUshort()
+//
+//infix fun Int.udiv(b: Byte) = (toUlong() / b.toUlong()).toInt()
+//infix fun Int.urem(b: Byte) = (toUlong() % b.toUlong()).toInt()
+//infix fun Int.ucmp(b: Byte) = toULong().compareTo(b.toUInt())
+//infix fun Int.ushr(b: Byte) = (toULong() ushr b.toUInt()).toInt()
+//
+//infix fun Int.udiv(b: Short) = (toULong() / b.toUInt()).toInt()
+//infix fun Int.urem(b: Short) = (toULong() % b.toUInt()).toInt()
+//infix fun Int.ucmp(b: Short) = toULong().compareTo(b.toUInt())
+//infix fun Int.ushr(b: Short) = (toULong() ushr b.toUInt()).toInt()
+//
+infix fun Int.udiv(b: Int): Int = (toUInt() / b.toUInt()).toInt()
+infix fun Int.urem(b: Int): Int = (toUInt() % b.toUInt()).toInt()
+infix fun Int.ucmp(b: Int): Int = toUInt().compareTo(b.toUInt())
+//// Int.ushr is already offered by the Kotlin lib
+//
+//infix fun Int.udiv(b: Long) = (toBigInt() / b.toBigInt()).toInt()
+//infix fun Int.urem(b: Long) = (toBigInt() % b.toBigInt()).toInt()
+//infix fun Int.ucmp(b: Long) = toBigInt().compareTo(b.toBigInt())
+//// no Int ushr Long
+//
+//
+//operator fun Int.plus(b: Ubyte) = this + b.v
+//operator fun Int.minus(b: Ubyte) = this - b.v
+//operator fun Int.times(b: Ubyte) = this * b.v
+//infix fun Int.and(b: Ubyte) = this and b.toInt()
+//infix fun Int.or(b: Ubyte) = this or b.toInt()
+//infix fun Int.xor(b: Ubyte) = this xor b.toInt()
+//infix fun Int.shl(b: Ubyte) = this shl b.toInt()
+//
+//infix fun Int.udiv(b: Ubyte) = (toULong() / b.toLong()).toInt()
+//infix fun Int.urem(b: Ubyte) = (toULong() % b.toLong()).toInt()
+//infix fun Int.ucmp(b: Ubyte) = toULong().compareTo(b.toLong())
+//infix fun Int.ushr(b: Ubyte) = this ushr b.toInt()
+//
+//
+//operator fun Int.plus(b: Ushort) = this + b.v
+//operator fun Int.minus(b: Ushort) = this - b.v
+//operator fun Int.times(b: Ushort) = this * b.v
+//infix fun Int.and(b: Ushort) = this and b.toInt()
+//infix fun Int.or(b: Ushort) = this or b.toInt()
+//infix fun Int.xor(b: Ushort) = this xor b.toInt()
+//infix fun Int.shl(b: Ushort) = this shl b.toInt()
+//
+//infix fun Int.udiv(b: Ushort) = (toULong() / b.toLong()).toInt()
+//infix fun Int.urem(b: Ushort) = (toULong() % b.toLong()).toInt()
+//infix fun Int.ucmp(b: Ushort) = toULong().compareTo(b.toLong())
+//infix fun Int.ushr(b: Ushort) = (toULong() ushr b.toInt()).toInt()
+//
+//
+//operator fun Int.plus(b: Uint) = this + b.v
+//operator fun Int.minus(b: Uint) = this - b.v
+//operator fun Int.times(b: Uint) = this * b.v
+//infix fun Int.and(b: Uint) = this and b.toInt()
+//infix fun Int.or(b: Uint) = this or b.toInt()
+//infix fun Int.xor(b: Uint) = this xor b.toInt()
+//infix fun Int.shl(b: Uint) = this shl b.v
+//
+//infix fun Int.udiv(b: Uint) = (toULong() / b.toLong()).toInt()
+//infix fun Int.urem(b: Uint) = (toULong() % b.toLong()).toInt()
+//infix fun Int.ucmp(b: Uint) = toULong().compareTo(b.toLong())
+//infix fun Int.ushr(b: Uint) = (toULong() ushr b.toInt()).toInt()
+//
+//
+//operator fun Int.plus(b: Ulong) = (this + b.v).toInt()
+//operator fun Int.minus(b: Ulong) = (this - b.v).toInt()
+//operator fun Int.times(b: Ulong) = (this * b.v).toInt()
+//infix fun Int.and(b: Ulong) = this and b.toInt()
+//infix fun Int.or(b: Ulong) = this or b.toInt()
+//infix fun Int.xor(b: Ulong) = this xor b.toInt()
+//infix fun Int.shl(b: Ulong) = this shl b.toInt()
+//
+//infix fun Int.udiv(b: Ulong) = (toULong() / b.toLong()).toInt()
+//infix fun Int.urem(b: Ulong) = (toULong() % b.toLong()).toInt()
+//infix fun Int.ucmp(b: Ulong) = toULong().compareTo(b.toLong())
+//// no Int ushr Ulong
+//
+//
+//// binds jdk unsigned operation
+//
+//infix fun Int.toUnsignedString(radix: Int): String = Integer.toUnsignedString(this, radix)
+///** no-radix version has a different codepath */
+//val Int.toUnsignedString: String
+//    get() = Integer.toUnsignedString(this)
+//
+//fun String.parseUnsignedInt(radix: Int = 10): Int = Integer.parseUnsignedInt(this, radix)
+//
+//infix fun Int.compareUnsigned(b: Int): Int = Integer.compareUnsigned(this, b)
+//
+//fun Int.toUnsignedLong(): Long = toLong() and 0xffffffffL
+//
+//infix fun Int.divideUnsigned(divisor: Int) = Integer.divideUnsigned(this, divisor)
+//infix fun Int.remainderUnsigned(divisor: Int) = Integer.remainderUnsigned(this, divisor)
diff --git a/src/commonMain/kotlin/unsigned/Long.kt b/src/commonMain/kotlin/unsigned/Long.kt
new file mode 100644
index 0000000..d94ed01
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Long.kt
@@ -0,0 +1,139 @@
+package unsigned
+
+
+//import com.ionspin.kotlin.bignum.integer.BigInteger
+//import com.ionspin.kotlin.bignum.integer.toBigInteger
+//
+//
+//// Created by GBarbieri on 31.01.2017.
+//
+//fun Long.toUbyte(): Ubyte = Ubyte(this)
+//fun Long.toUshort(): Ushort = Ushort(this)
+//fun Long.toUint(): Uint = Uint(this)
+//fun Long.toUlong(): Ulong = Ulong(this)
+//
+//fun Long.toBigInt(): BigInteger = BigInteger.fromLong(this)
+//fun Long.toUBigInt(): BigInteger = BigInteger.fromULong(toULong())
+//
+//val Long.ub
+//    get() = toUbyte()
+//val Long.ui
+//    get() = toUint()
+//val Long.ul
+//    get() = toUlong()
+//val Long.us
+//    get() = toUshort()
+//
+//infix fun Long.udiv(b: Byte): Long = (toUBigInt() / b.toUBigInt()).longValue()
+//infix fun Long.urem(b: Byte): Long = (toUBigInt() % b.toUBigInt()).longValue()
+//infix fun Long.ucmp(b: Byte): Int = toUBigInt().compareTo(b.toUBigInt())
+//infix fun Long.ushr(b: Byte): Long = (toUBigInt() shr b.toUInt()).longValue()
+//
+//infix fun Long.udiv(b: Short) = (toUBigInt() / b.toUBigInt()).toLong()
+//infix fun Long.urem(b: Short) = (toUBigInt() % b.toUBigInt()).toLong()
+//infix fun Long.ucmp(b: Short) = toUBigInt().compareTo(b.toUBigInt())
+//infix fun Long.ushr(b: Short) = (toUBigInt() ushr b.toUInt()).toLong()
+//
+//infix fun Long.udiv(b: Int) = (toUBigInt() / b.toUBigInt()).toLong()
+//infix fun Long.urem(b: Int) = (toUBigInt() % b.toUBigInt()).toLong()
+//infix fun Long.ucmp(b: Int) = toUBigInt().compareTo(b.toUBigInt())
+//// Long.ushr(b: Int) offered by Kotlin lib
+
+infix fun Long.udiv(b: Long): Long = (toULong() / b.toULong()).toLong()
+infix fun Long.urem(b: Long): Long = (toULong() % b.toULong()).toLong()
+infix fun Long.ucmp(b: Long): Int = toULong().compareTo(b.toULong())
+// no Long ushr Long
+//
+//
+//operator fun Long.plus(b: Ubyte) = this + b.v
+//operator fun Long.minus(b: Ubyte) = this - b.v
+//operator fun Long.times(b: Ubyte) = this * b.v
+//infix fun Long.and(b: Ubyte) = this and b.toLong()
+//infix fun Long.or(b: Ubyte) = this or b.toLong()
+//infix fun Long.xor(b: Ubyte) = this xor b.toLong()
+//infix fun Long.shl(b: Ubyte) = this shl b.toInt()
+//
+//infix fun Long.udiv(b: Ubyte) = (toUBigInt() / b.toBigInt()).toLong()
+//infix fun Long.urem(b: Ubyte) = (toUBigInt() % b.toBigInt()).toLong()
+//infix fun Long.ucmp(b: Ubyte) = toUBigInt().compareTo(b.toBigInt())
+//infix fun Long.ushr(b: Ubyte) = this ushr b.toInt()
+//
+//
+//operator fun Long.plus(b: Ushort) = this + b.v
+//operator fun Long.minus(b: Ushort) = this - b.v
+//operator fun Long.times(b: Ushort) = this * b.v
+//infix fun Long.and(b: Ushort) = this and b.toLong()
+//infix fun Long.or(b: Ushort) = this or b.toLong()
+//infix fun Long.xor(b: Ushort) = this xor b.toLong()
+//infix fun Long.shl(b: Ushort) = this shl b.toInt()
+//
+//infix fun Long.udiv(b: Ushort) = (toUBigInt() / b.toBigInt()).toLong()
+//infix fun Long.urem(b: Ushort) = (toUBigInt() % b.toBigInt()).toLong()
+//infix fun Long.ucmp(b: Ushort) = toUBigInt().compareTo(b.toBigInt())
+//infix fun Long.ushr(b: Ushort) = (toUBigInt() ushr b.toInt()).toLong()
+//
+//
+//operator fun Long.plus(b: Uint) = this + b.v
+//operator fun Long.minus(b: Uint) = this - b.v
+//operator fun Long.times(b: Uint) = this * b.v
+//infix fun Long.and(b: Uint) = this and b.toLong()
+//infix fun Long.or(b: Uint) = this or b.toLong()
+//infix fun Long.xor(b: Uint) = this xor b.toLong()
+//infix fun Long.shl(b: Uint) = this shl b.v
+//
+//infix fun Long.udiv(b: Uint) = (toUBigInt() / b.toBigInt()).toLong()
+//infix fun Long.urem(b: Uint) = (toUBigInt() % b.toBigInt()).toLong()
+//infix fun Long.ucmp(b: Uint) = toUBigInt().compareTo(b.toBigInt())
+//infix fun Long.ushr(b: Uint) = (toUBigInt() ushr b.toInt()).toLong()
+//
+//
+//operator fun Long.plus(b: Ulong) = this + b.v
+//operator fun Long.minus(b: Ulong) = this - b.v
+//operator fun Long.times(b: Ulong) = this * b.v
+//infix fun Long.and(b: Ulong) = this and b.toLong()
+//infix fun Long.or(b: Ulong) = this or b.toLong()
+//infix fun Long.xor(b: Ulong) = this xor b.toLong()
+//infix fun Long.shl(b: Ulong) = this shl b.toInt()
+//
+//infix fun Long.udiv(b: Ulong) = (toUBigInt() / b.toBigInt()).toLong()
+//infix fun Long.urem(b: Ulong) = (toUBigInt() % b.toBigInt()).toLong()
+//infix fun Long.ucmp(b: Ulong) = toUBigInt().compareTo(b.toBigInt())
+//// no Int ushr Ulong
+//
+//
+//infix fun Long.toUnsignedString(radix: Int): String = java.lang.Long.toUnsignedString(this, radix)
+//
+//fun Long.toUnsignedBigInteger(): BigInteger = when {
+//    this >= 0L -> BigInteger.valueOf(this)
+//    else -> {
+//        val upper = ushr(32).toInt()
+//        val lower = toInt()
+//
+//        // return (upper << 32) + lower
+//        BigInteger.valueOf(upper.toLong() and 0xffffffffL).shiftLeft(32) + BigInteger.valueOf(lower.toLong() and 0xffffffffL)
+//    }
+//}
+//
+///** no-radix version has a different codepath */
+//val Long.toUnsignedString: String
+//    get() = toULong().toBigInteger().toString()
+//
+//fun String.parseUnsignedLong(radix: Int = 10): Ulong = BigInteger.parseString(this, radix).longValue().ul
+//
+//infix fun Long.compareUnsigned(b: Long): Int = compare(this + Long.MIN_VALUE, b + Long.MIN_VALUE)
+//fun compare(x: Long, y: Long): Int = if (x < y) -1 else if (x == y) 0 else 1
+//
+//infix fun Long.divideUnsigned(divisor: Long): Long = when {
+//    divisor < 0L -> if (compareUnsigned(divisor) < 0) 0L else 1L
+//    this > 0L -> this / divisor
+//    else -> (toUnsignedBigInteger() / divisor.toUnsignedBigInteger()).longValue()
+//}
+//
+//infix fun Long.remainderUnsigned(divisor: Long): Long = when {
+//    this > 0L && divisor > 0L -> this % divisor
+//    compareUnsigned(divisor) < 0 -> this
+//    else -> (toUnsignedBigInteger() % divisor.toUnsignedBigInteger()).longValue()
+//}
+//
+//
+//
diff --git a/src/commonMain/kotlin/unsigned/Short.kt b/src/commonMain/kotlin/unsigned/Short.kt
new file mode 100644
index 0000000..04cdc3b
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Short.kt
@@ -0,0 +1,104 @@
+/**
+ * Created by GBarbieri on 03.02.2017.
+ */
+
+package unsigned
+
+//import java.math.BigInteger
+//import kotlin.experimental.and
+//import kotlin.experimental.or
+//import kotlin.experimental.xor
+//
+//
+//fun Short.toUbyte() = Ubyte(this)
+//fun Short.toUshort() = Ushort(this)
+//fun Short.toUint() = Uint(toUInt())
+//fun Short.toUlong() = Ulong(toUInt())
+//
+//fun Short.toBigInt(): BigInteger = BigInteger.valueOf(toLong())
+//fun Short.toUBigInt(): BigInteger = BigInteger.valueOf(toULong())
+//
+//val Short.ub
+//    get() = toUbyte()
+//val Short.ui
+//    get() = toUint()
+//val Short.ul
+//    get() = toUlong()
+//val Short.us
+//    get() = toUshort()
+//
+//infix fun Short.udiv(b: Byte) = (toUInt() / b.toUInt()).toShort()
+//infix fun Short.urem(b: Byte) = (toUInt() % b.toUInt()).toShort()
+//infix fun Short.ucmp(b: Byte) = toUInt().compareTo(b.toUInt())
+//infix fun Short.ushr(b: Byte) = (toUInt() ushr b.toUInt()).toShort()
+//
+infix fun Short.udiv(b: Short): Short = (toUShort() / b.toUShort()).toShort()
+infix fun Short.urem(b: Short): Short = (toUShort() % b.toUShort()).toShort()
+infix fun Short.ucmp(b: Short): Int = toUShort().compareTo(b.toUShort())
+infix fun Short.ushr(b: Short): Short = (toUShort().toUInt() shr b.toInt()).toShort()
+//
+//infix fun Short.udiv(b: Int) = (toULong() / b.toULong()).toShort()
+//infix fun Short.urem(b: Int) = (toULong() % b.toULong()).toShort()
+//infix fun Short.ucmp(b: Int) = toULong().compareTo(b.toULong())
+//infix fun Short.ushr(b: Int) = (toUInt() ushr b).toShort()
+//
+//infix fun Short.udiv(b: Long) = (toBigInt() / b.toBigInt()).toShort()
+//infix fun Short.urem(b: Long) = (toBigInt() % b.toBigInt()).toShort()
+//infix fun Short.ucmp(b: Long) = toBigInt().compareTo(b.toBigInt())
+//// no Short ushr Long
+//
+//
+//operator fun Short.plus(b: Ubyte) = (this + b.v).toShort()
+//operator fun Short.minus(b: Ubyte) = (this - b.v).toShort()
+//operator fun Short.times(b: Ubyte) = (this * b.v).toShort()
+//infix fun Short.and(b: Ubyte) = this and b.toShort()
+//infix fun Short.or(b: Ubyte) = this or b.toShort()
+//infix fun Short.xor(b: Ubyte) = this xor b.toShort()
+//infix fun Short.shl(b: Ubyte) = (toInt() shl b.toInt()).toShort()
+//
+//infix fun Short.udiv(b: Ubyte) = (toUInt() / b.toInt()).toShort()
+//infix fun Short.urem(b: Ubyte) = (toUInt() % b.toInt()).toShort()
+//infix fun Short.ucmp(b: Ubyte) = toUInt().compareTo(b.toInt())
+//infix fun Short.ushr(b: Ubyte) = (toUInt() ushr b.toInt()).toShort()
+//
+//
+//operator fun Short.plus(b: Ushort) = (this + b.v).toShort()
+//operator fun Short.minus(b: Ushort) = (this - b.v).toShort()
+//operator fun Short.times(b: Ushort) = (this * b.v).toShort()
+//infix fun Short.and(b: Ushort) = this and b.v
+//infix fun Short.or(b: Ushort) = this or b.v
+//infix fun Short.xor(b: Ushort) = this xor b.v
+//infix fun Short.shl(b: Ushort) = (toInt() shl b.toInt()).toShort()
+//
+//infix fun Short.udiv(b: Ushort) = (toUInt() / b.toInt()).toShort()
+//infix fun Short.urem(b: Ushort) = (toUInt() % b.toInt()).toShort()
+//infix fun Short.ucmp(b: Ushort) = toUInt().compareTo(b.toInt())
+//infix fun Short.ushr(b: Ushort) = (toUInt() ushr b.toInt()).toShort()
+//
+//
+//operator fun Short.plus(b: Uint) = (this + b.v).toShort()
+//operator fun Short.minus(b: Uint) = (this - b.v).toShort()
+//operator fun Short.times(b: Uint) = (this * b.v).toShort()
+//infix fun Short.and(b: Uint) = this and b.toShort()
+//infix fun Short.or(b: Uint) = this or b.toShort()
+//infix fun Short.xor(b: Uint) = this xor b.toShort()
+//infix fun Short.shl(b: Uint) = (toInt() shl b.v).toShort()
+//
+//infix fun Short.udiv(b: Uint) = (toULong() / b.toLong()).toShort()
+//infix fun Short.urem(b: Uint) = (toULong() % b.toLong()).toShort()
+//infix fun Short.ucmp(b: Uint) = toULong().compareTo(b.toLong())
+//infix fun Short.ushr(b: Uint) = (toUInt() ushr b.toInt()).toShort()
+//
+//
+//operator fun Short.plus(b: Ulong) = (this + b.v).toShort()
+//operator fun Short.minus(b: Ulong) = (this - b.v).toShort()
+//operator fun Short.times(b: Ulong) = (this * b.v).toShort()
+//infix fun Short.and(b: Ulong) = this and b.toShort()
+//infix fun Short.or(b: Ulong) = this or b.toShort()
+//infix fun Short.xor(b: Ulong) = this xor b.toShort()
+//infix fun Short.shl(b: Ulong) = (toInt() shl b.toInt()).toShort()
+//
+//infix fun Short.udiv(b: Ulong) = (toULong() / b.toLong()).toShort()
+//infix fun Short.urem(b: Ulong) = (toULong() % b.toLong()).toShort()
+//infix fun Short.ucmp(b: Ulong) = toULong().compareTo(b.toLong())
+//// no Short ushr Ulong
\ No newline at end of file
diff --git a/src/commonMain/kotlin/unsigned/Ubyte.kt b/src/commonMain/kotlin/unsigned/Ubyte.kt
new file mode 100644
index 0000000..504fd71
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Ubyte.kt
@@ -0,0 +1,107 @@
+package unsigned
+//
+//import com.ionspin.kotlin.bignum.integer.BigInteger
+//import kotlin.experimental.and
+//import kotlin.experimental.inv
+//import kotlin.jvm.JvmOverloads
+//
+///**
+// * Created by GBarbieri on 20.03.2017.
+// */
+//
+//class Ubyte(var v: Byte) : Number(), Comparable<Ubyte> {
+//
+//    companion object {
+//
+//        /** A constant holding the minimum value an <code>unsigned byte</code> can have, 0. */
+//        const val MIN_VALUE: Int = 0
+//        /** A constant holding the maximum value an <code>unsigned byte</code> can have, 2<sup>8</sup>-1.   */
+//        const val MAX_VALUE: Int = 0xff
+//
+//        /** A constant holding the minimum value an <code>unsigned byte</code> can have, 0. */
+//        val MIN = Ubyte(0)
+//        /** A constant holding the maximum value an <code>unsigned byte</code> can have, 2<sup>8</sup>-1.   */
+//        val MAX = Ubyte(0xff)
+//
+//        fun checkSigned(v: Number) = v.toInt() in MIN_VALUE..MAX_VALUE
+//    }
+//
+//    constructor(number: Number) : this(number.toByte())
+//    @JvmOverloads
+//    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base).toByte())
+//
+//    override fun toByte() = v
+//    override fun toShort() = v.toUInt().toShort()
+//    override fun toInt() = v.toUInt()
+//    override fun toLong() = v.toULong()
+//
+//    fun toBigInt(): BigInteger = BigInteger.valueOf(toLong())
+//
+//    override fun toDouble() = toInt().toDouble()
+//    override fun toFloat() = toInt().toFloat()
+//
+//    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+//    override fun toChar() = toInt().toChar()
+//
+//    fun toUbyte() = this
+//    fun toUshort() = Ushort(toInt())
+//    fun toUint() = Uint(toInt())
+//    fun toUlong() = Ulong(toInt())
+//
+//    operator fun inc() = Ubyte(v + 1)
+//    operator fun dec() = Ubyte(v - 1)
+//
+//    infix operator fun plus(b: Ubyte) = Ubyte(toInt() + b.toInt())
+//    infix operator fun plus(b: Byte) = Ubyte(toInt() + b.toUInt())
+//    infix operator fun plus(b: Int) = Ubyte(toInt() + b)
+//
+//    infix operator fun minus(b: Ubyte) = Ubyte(toInt() - b.toInt())
+//    infix operator fun minus(b: Byte) = Ubyte(toInt() - b.toUInt())
+//    infix operator fun minus(b: Int) = Ubyte(toInt() - b)
+//
+//    infix operator fun times(b: Ubyte) = Ubyte(toInt() * b.toInt())
+//    infix operator fun times(b: Byte) = Ubyte(toInt() * b.toUInt())
+//    infix operator fun times(b: Int) = Ubyte(toInt() * b)
+//
+//    infix operator fun div(b: Ubyte) = Ubyte(toInt() / b.toInt())
+//    infix operator fun div(b: Byte) = Ubyte(toInt() / b.toUInt())
+//    infix operator fun div(b: Int) = Ubyte(toInt() udiv b)
+//
+//    infix operator fun rem(b: Ubyte) = Ubyte(toInt() % b.toInt())
+//    infix operator fun rem(b: Byte) = Ubyte(toInt() % b.toUInt())
+//    infix operator fun rem(b: Int) = Ubyte(toInt() urem b)
+//
+//    // TODO add counterparts with res
+//
+//    infix fun and(b: Ubyte) = Ubyte(v and b.v)
+//    infix fun and(b: Byte) = Ubyte(v and b)
+//    infix fun and(b: Int) = Ubyte(toInt() and b)
+//
+//    infix fun or(b: Ubyte) = Ubyte(toInt() or b.toInt())
+//    infix fun or(b: Byte) = Ubyte(toInt() or b.toUInt())
+//    infix fun or(b: Int) = Ubyte(toInt() or b)
+//
+//    infix fun xor(b: Ubyte) = Ubyte(toInt() xor b.toInt())
+//    infix fun xor(b: Byte) = Ubyte(toInt() xor b.toUInt())
+//    infix fun xor(b: Int) = Ubyte(toInt() xor b)
+//
+//    infix fun shl(b: Ubyte) = Ubyte(toInt() shl b.toInt())
+//    infix fun shl(b: Byte) = Ubyte(toInt() shl b.toUInt())
+//    infix fun shl(b: Int) = Ubyte(toInt() shl b)
+//
+//    infix fun shr(b: Ubyte) = Ubyte(toInt() ushr b.toInt())
+//    infix fun shr(b: Byte) = Ubyte(toInt() ushr b.toUInt())
+//    infix fun shr(b: Int) = Ubyte(toInt() ushr b)
+//
+//    fun inv() = Ubyte(v.inv())
+//
+//    override operator fun compareTo(other: Ubyte) = toInt() compareUnsigned other.toInt()
+//    operator fun compareTo(other: Byte) = toInt() compareUnsigned other.toUInt()
+//    operator fun compareTo(other: Int) = toInt() compareUnsigned other
+//
+//    override fun equals(other: Any?) = other is Ubyte && v == other.v
+//    override fun hashCode(): Int = v.hashCode()
+//    override fun toString() = toInt().toString()
+//    fun toString(radix: Int) = toInt().toString(radix)
+//    fun toString(format: String) = format.format(toInt())
+//}
diff --git a/src/commonMain/kotlin/unsigned/Uint.kt b/src/commonMain/kotlin/unsigned/Uint.kt
new file mode 100644
index 0000000..5b7991d
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Uint.kt
@@ -0,0 +1,91 @@
+package unsigned
+//
+//import java.math.BigInteger
+//
+///**
+// * Created by GBarbieri on 20.03.2017.
+// */
+//
+//data class Uint(var v: Int = 0) : Number(), Comparable<Uint> {
+//
+//    companion object {
+//
+//        /** A constant holding the minimum value an <code>unsigned int</code> can have, 0.  */
+//        const val MIN_VALUE: Long = 0L
+//
+//        /** A constant holding the maximum value an <code>unsigned int</code> can have, 2<sup>32</sup>-1.   */
+//        const val MAX_VALUE: Long = 0xffffffffL
+//
+//        /** A constant holding the minimum value an <code>unsigned int</code> can have, 0.  */
+//        val MIN = Uint(0)
+//
+//        /** A constant holding the maximum value an <code>unsigned int</code> can have, 2<sup>32</sup>-1.   */
+//        val MAX = Uint(-1)
+//
+//        fun checkSigned(v: Number) = v.toLong() in MIN_VALUE..MAX_VALUE
+//    }
+//
+//
+//    constructor(number: Number) : this(number.toInt())
+//    @JvmOverloads
+//    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base))
+//
+//    override fun toByte() = v.toByte()
+//    override fun toShort() = v.toShort()
+//    override fun toInt() = v
+//    override fun toLong() = v.toULong()
+//
+//    fun toBigInt(): BigInteger = BigInteger.valueOf(toLong())
+//
+//    override fun toDouble() = toLong().toDouble()
+//    override fun toFloat() = toLong().toFloat()
+//
+//    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+//    override fun toChar() = v.toChar()
+//
+//    operator fun inc() = Uint(v + 1)
+//    operator fun dec() = Uint(v - 1)
+//
+//    infix operator fun plus(b: Uint) = Uint(v + b.v)
+//    infix operator fun plus(b: Int) = Uint(v + b)
+//
+//    infix operator fun minus(b: Uint) = Uint(v - b.v)
+//    infix operator fun minus(b: Int) = Uint(v - b)
+//
+//    infix operator fun times(b: Uint) = Uint(v * b.v)
+//    infix operator fun times(b: Int) = Uint(v * b)
+//
+//    infix operator fun div(b: Uint) = Uint(v udiv b.toInt())
+//    infix operator fun div(b: Int) = Uint(v udiv b)
+//
+//    infix operator fun rem(b: Uint) = Uint(v urem b.toInt())
+//    infix operator fun rem(b: Int) = Uint(v urem b)
+//
+//    infix fun and(b: Uint) = Uint(v and b.toInt())
+//    infix fun and(b: Int) = Uint(v and b)
+//
+//    infix fun or(b: Uint) = Uint(v or b.toInt())
+//    infix fun or(b: Int) = Uint(v or b)
+//
+//    infix fun xor(b: Uint) = Uint(v xor b.toInt())
+//    infix fun xor(b: Int) = Uint(v xor b)
+//
+//    infix fun shl(b: Uint) = Uint(v shl b.toInt())
+//    infix fun shl(b: Int) = Uint(v shl b)
+//
+//    infix fun shr(b: Uint) = Uint(v ushr b.toInt())
+//    infix fun shr(b: Int) = Uint(v ushr b)
+//
+//    fun inv() = Uint(v.inv())
+//
+//    override operator fun compareTo(other: Uint) = v compareUnsigned other.toInt()
+//    operator fun compareTo(other: Int) = v compareUnsigned other
+//
+//    override fun equals(other: Any?) = other is Uint && v == other.v
+//    override fun hashCode(): Int = v.hashCode()
+//    override fun toString() = toLong().toString()
+//    fun toString(radix: Int) = toLong().toString(radix)
+//    fun toString(format: String) = format.format(toLong())
+//
+//    // TODO long?
+//}
\ No newline at end of file
diff --git a/src/commonMain/kotlin/unsigned/Ulong.kt b/src/commonMain/kotlin/unsigned/Ulong.kt
new file mode 100644
index 0000000..95411ca
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Ulong.kt
@@ -0,0 +1,107 @@
+package unsigned
+//
+//import com.ionspin.kotlin.bignum.integer.BigInteger
+//
+///**
+// * Created by GBarbieri on 20.03.2017.
+// */
+//
+//data class Ulong(var v: Long = 0) : Number(), Comparable<Ulong> {
+//
+//    companion object {
+//
+//        /** A constant holding the minimum value an <code>unsigned long</code> can have, 0. */
+//        val MIN_VALUE: BigInteger = BigInteger.ZERO
+//
+//        /** A constant holding the maximum value an <code>unsigned long</code> can have, 2<sup>64</sup>-1.  */
+//        val MAX_VALUE = BigInteger.parseString("18446744073709551615")
+//
+//        /** A constant holding the minimum value an <code>unsigned long</code> can have, 0. */
+//        val MIN = Ulong(0L)
+//
+//        /** A constant holding the maximum value an <code>unsigned long</code> can have, 2<sup>64</sup>-1.  */
+//        val MAX = Ulong(-1L)
+//
+//        fun checkSigned(v: Number) = BigInteger.fromLong(v.toLong()) in MIN_VALUE..MAX_VALUE
+//    }
+//
+//    constructor(number: Number) : this(number.toLong())
+//    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedLong(base))
+//
+//    override fun toByte(): Byte = v.toByte()
+//    override fun toShort(): Short = v.toShort()
+//    override fun toInt(): Int = v.toInt()
+//    override fun toLong(): Long = v
+//
+//    fun toBigInt(): BigInteger = BigInteger.fromULong(v.toULong())
+//
+//    override fun toDouble(): Double = toBigInt().doubleValue()
+//    override fun toFloat(): Float = toBigInt().floatValue()
+//
+//    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+//    override fun toChar(): Char = v.toInt().toChar()
+//
+//    operator fun inc(): Ulong = Ulong(v + 1)
+//    operator fun dec(): Ulong = Ulong(v - 1)
+//
+//    infix operator fun plus(b: Ulong): Ulong = Ulong(v + b.v)
+//    infix operator fun plus(b: Long): Ulong = Ulong(v + b)
+//
+//    infix operator fun minus(b: Ulong): Ulong = Ulong(v - b.v)
+//    infix operator fun minus(b: Long): Ulong = Ulong(v - b)
+//
+//    infix operator fun times(b: Ulong): Ulong = Ulong(v * b.v)
+//    infix operator fun times(b: Long): Ulong = Ulong(v * b)
+//
+//    infix operator fun div(b: Ulong) = Ulong(v divideUnsigned b.toLong())
+//    infix operator fun div(b: Long) = Ulong(v divideUnsigned b)
+//
+//    infix operator fun rem(b: Ulong) = Ulong(v remainderUnsigned b.toLong())
+//    infix operator fun rem(b: Long) = Ulong(v remainderUnsigned b)
+//
+//    infix fun and(b: Ulong) = Ulong(v and b.toLong())
+//    infix fun and(b: Long) = Ulong(v and b)
+//
+//    infix fun or(b: Ulong) = Ulong(v or b.toLong())
+//    infix fun or(b: Long) = Ulong(v or b)
+//
+//    infix fun xor(b: Ulong) = Ulong(v xor b.toLong())
+//    infix fun xor(b: Long) = Ulong(v xor b)
+//
+//    infix fun shl(b: Int) = Ulong(v shl b)
+//
+//    infix fun shr(b: Int) = Ulong(v ushr b)
+//
+//    fun inv() = Ulong(v.inv())
+//
+//    override operator fun compareTo(other: Ulong) = v compareUnsigned other.toLong()
+//    operator fun compareTo(other: Long) = v compareUnsigned other
+//
+//    // TODO others
+//
+//    override fun equals(other: Any?) = other is Ulong && v == other.v
+//    override fun hashCode(): Int = v.hashCode()
+//    override fun toString() = toBigInt().toString()
+//    fun toString(radix: Int) = toBigInt().toString(radix)
+//    fun toString(format: String) = format.format(toBigInt())
+//
+//    operator fun rangeTo(b: Ulong) = UlongRange(this, b)
+//
+//    class UlongRange(override val start: Ulong, override val endInclusive: Ulong) : ClosedRange<Ulong>, Iterable<Ulong> {
+//
+//        override fun iterator(): Iterator<Ulong> = UlongIterator(this)
+//
+//        override fun contains(value: Ulong): Boolean = value in start..endInclusive
+//    }
+//
+//    class UlongIterator(val ulongRange: UlongRange) : Iterator<Ulong> {
+//        var current = ulongRange.start
+//        override fun next(): Ulong {
+//            val result = current
+//            current++
+//            return result
+//        }
+//
+//        override fun hasNext() = current <= ulongRange.endInclusive
+//    }
+//}
\ No newline at end of file
diff --git a/src/commonMain/kotlin/unsigned/Ushort.kt b/src/commonMain/kotlin/unsigned/Ushort.kt
new file mode 100644
index 0000000..ff63997
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/Ushort.kt
@@ -0,0 +1,108 @@
+package unsigned
+//
+//import java.math.BigInteger
+//import kotlin.experimental.and
+//import kotlin.experimental.inv
+//import kotlin.experimental.or
+//import kotlin.experimental.xor
+//import kotlin.jvm.JvmOverloads
+//
+///**
+// * Created by GBarbieri on 20.03.2017.
+// */
+//
+//data class Ushort(var v: Short = 0) : Number(), Comparable<Ushort> {
+//
+//    companion object {
+//
+//        /** A constant holding the minimum value an <code>unsigned short</code> can have, 0.    */
+//        const val MIN_VALUE: Int = 0
+//
+//        /** A constant holding the maximum value an <code>unsigned short</code> can have, 2<sup>16</sup>-1. */
+//        const val MAX_VALUE: Int = 0xffff
+//
+//        /** A constant holding the minimum value an <code>unsigned short</code> can have, 0.    */
+//        val MIN = Ushort(0)
+//
+//        /** A constant holding the maximum value an <code>unsigned short</code> can have, 2<sup>16</sup>-1. */
+//        val MAX = Ushort(0xffff)
+//
+//        fun checkSigned(v: Number) = v.toInt() in MIN_VALUE..MAX_VALUE
+//    }
+//
+//    constructor(number: Number) : this(number.toShort())
+//
+//    @JvmOverloads
+//    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base).toShort())
+//
+//    override fun toByte() = v.toByte()
+//    override fun toShort() = v
+//    override fun toInt() = v.toUInt()
+//    override fun toLong() = v.toULong()
+//
+//    fun toBigInt(): BigInteger = BigInteger.valueOf(toLong())
+//
+//    override fun toDouble() = toInt().toDouble()
+//    override fun toFloat() = toInt().toFloat()
+//
+//    @Deprecated(
+//        "Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration",
+//        replaceWith = ReplaceWith("this.toInt().toChar()")
+//    )
+//    override fun toChar() = v.toInt().toChar()
+//
+//    operator fun inc() = Ushort(v + 1)
+//    operator fun dec() = Ushort(v - 1)
+//
+//    infix operator fun plus(b: Ushort) = Ushort(toInt() + b.toInt())
+//    infix operator fun plus(b: Short) = Ushort(toInt() + b.toUInt())
+//    infix operator fun plus(b: Int) = Ushort(toInt() + b)
+//
+//    infix operator fun minus(b: Ushort) = Ushort(toInt() - b.toInt())
+//    infix operator fun minus(b: Short) = Ushort(toInt() - b.toUInt())
+//    infix operator fun minus(b: Int) = Ushort(toInt() - b)
+//
+//    infix operator fun times(b: Ushort) = Ushort(toInt() * b.toInt())
+//    infix operator fun times(b: Short) = Ushort(toInt() * b.toUInt())
+//    infix operator fun times(b: Int) = Ushort(toInt() * b)
+//
+//    infix operator fun div(b: Ushort) = Ushort(toInt() / b.toInt())
+//    infix operator fun div(b: Short) = Ushort(toInt() / b.toUInt())
+//    infix operator fun div(b: Int) = Ushort(toInt() udiv b)
+//
+//    infix operator fun rem(b: Ushort) = Ushort(toInt() % b.toInt())
+//    infix operator fun rem(b: Short) = Ushort(toInt() % b.toUInt())
+//    infix operator fun rem(b: Int) = Ushort(toInt() urem b)
+//
+//    infix fun and(b: Ushort) = Ushort(v and b.v)
+//    infix fun and(b: Short) = Ushort(v and b)
+//    infix fun and(b: Int) = Ushort(toInt() and b)
+//
+//    infix fun or(b: Ushort) = Ushort(v or b.v)
+//    infix fun or(b: Short) = Ushort(v or b)
+//    infix fun or(b: Int) = Ushort(toInt() or b)
+//
+//    infix fun xor(b: Ushort) = Ushort(v xor b.v)
+//    infix fun xor(b: Short) = Ushort(v xor b)
+//    infix fun xor(b: Int) = Ushort(toInt() xor b)
+//
+//    infix fun shl(b: Ushort) = Ushort(toInt() shl b.toInt())
+//    infix fun shl(b: Short) = Ushort(toInt() shl b.toUInt())
+//    infix fun shl(b: Int) = Ushort(toInt() shl b)
+//
+//    infix fun shr(b: Ushort) = Ushort(toInt() ushr b.toInt())
+//    infix fun shr(b: Short) = Ushort(toInt() ushr b.toUInt())
+//    infix fun shr(b: Int) = Ushort(toInt() ushr b)
+//
+//    fun inv() = Ushort(v.inv())
+//
+//    override operator fun compareTo(other: Ushort) = toInt() compareUnsigned other.toInt()
+//    operator fun compareTo(other: Short) = toInt() compareUnsigned other.toUInt()
+//    operator fun compareTo(other: Int) = toInt() compareUnsigned other
+//
+//    override fun equals(other: Any?) = other is Ushort && v == other.v
+//    override fun hashCode(): Int = v.hashCode()
+//    override fun toString() = toInt().toString()
+//    fun toString(radix: Int) = toInt().toString(radix)
+//    fun toString(format: String) = format.format(toInt())
+//}
\ No newline at end of file
diff --git a/src/commonMain/kotlin/unsigned/unsigned.kt b/src/commonMain/kotlin/unsigned/unsigned.kt
new file mode 100644
index 0000000..fde7175
--- /dev/null
+++ b/src/commonMain/kotlin/unsigned/unsigned.kt
@@ -0,0 +1,19 @@
+package unsigned
+
+/**
+ * Created by GBarbieri on 06.10.2016.
+ */
+
+// TODO if == unsigned.Ubyte?
+//fun Number.toUbyte() = Ubyte(toByte())
+//
+//fun Number.toUint() = Uint(this)
+//fun Number.toUlong() = Ulong(toLong())
+//fun Number.toUshort() = Ushort(toShort())
+//
+//// TODO char?
+//
+//fun Char.toUbyte() = Ubyte(code.toByte())
+//fun Char.toUint() = Uint(code)
+//fun Char.toUlong() = Ulong(code.toLong())
+//fun Char.toUshort() = Ushort(code.toShort())
\ No newline at end of file
diff --git a/src/commonTest/kotlin/unsigned/test.kt b/src/commonTest/kotlin/unsigned/test.kt
new file mode 100644
index 0000000..56d497c
--- /dev/null
+++ b/src/commonTest/kotlin/unsigned/test.kt
@@ -0,0 +1,90 @@
+package unsigned
+
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+import uns.*
+import kotlin.test.Test
+
+/**
+ * Created by elect on 15/10/16.
+ */
+
+//val Int.b
+//    get() = toByte()
+//val Int.s
+//    get() = toShort()
+//val Long.b
+//    get() = toByte()
+//val Long.s
+//    get() = toShort()
+//val Long.i
+//    get() = toInt()
+//val BigInteger.L
+//    get() = toLong()
+//
+//
+///**
+// * BUG, 0xffffffffffffffff is outside Long range
+// * https://youtrack.jetbrains.com/issue/KT-4749
+// */
+//val String.hL: Long
+//    get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' }, 16)
+//
+val String.L: Long
+    get() = filter { it != '_' && it != '\'' }.toBigInteger().longValue(false)
+//
+//val String.bL: Long
+//    get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' }, 2)
+
+
+class Unsigned {
+
+    @Test
+    fun primitive() {
+
+        250.i8 udiv 50 `==` 5
+        250.i8 urem 200.i8 `==` 50
+        250.i8 ucmp 251.i8 `==` -1
+        250.i8 ucmp 250.i8 `==` 0
+        0b1010_1010.i8 ushr 4 `==` 0b1010
+
+        65500.i16 udiv 500 `==` 131
+        65500.i16 urem 65000.i16 `==` 500
+        65500.i16 ucmp 65501.i16 `==` -1
+        65500.i16 ucmp 65500.i16 `==` 0
+        0b0100_1100_0011_1101.i16 ushr 8 `==` 0b100_1100
+
+        4_000_000_000.i32 udiv 2 `==` 2_000_000_000
+        2_750_000_000.i32 urem 2_000_000_000 `==` 750_000_000
+        4_000_000_000.i32 ucmp 4_000_000_001.i32 `==` -1
+        4_000_000_000.i32 ucmp 4_000_000_000.i32 `==` 0
+
+        "18_000_000_000_000_000_000".L udiv 2L `==` "9'000'000'000'000'000'000".L
+        "17'000'000'000'000'000'000".L urem "9'000'000'000'000'000'000".L `==` "8'000'000'000'000'000'000".L
+        "18'000'000'000'000'000'000".L ucmp "18'000'000'000'000'000'001".L `==` -1
+        "18'000'000'000'000'000'001".L ucmp "18'000'000'000'000'000'001".L `==` 0
+    }
+
+    @Test
+    fun stringFormat() {
+
+        U8(0xff).v.i8.toString() `==` "-1"
+        U8(0xff).toString() `==` "255"
+        U16(0xffff).v.i16.toString() `==` "-1"
+        U16(0xffff).toString() `==` "65535"
+        U32(0xffff_ffff).v.i16.toString() `==` "-1"
+        U32(0xffff_ffff).toString() `==` "4294967295"
+        U64(ULong.MAX_VALUE).v.i64.toString() `==` "-1"
+        U64(ULong.MAX_VALUE).toString() `==` "18446744073709551615"
+
+        U8.MIN.toString(16) `==` "0"
+        U8.MAX.toString(16) `==` "ff"
+        U16.MIN.toString(16) `==` "0"
+        U16.MAX.toString(16) `==` "ffff"
+        U32.MIN.toString(16) `==` "0"
+        U32.MAX.toString(16) `==` "ffffffff"
+        U64.MIN.toString(16) `==` "0"
+        U64.MAX.toString(16) `==` "ffffffffffffffff"
+
+        (-71777214294589696).ul.toString(2) `==` "1111111100000000111111110000000011111111000000001111111100000000"
+    }
+}
diff --git a/src/commonTest/kotlin/unsigned/u16_test.kt b/src/commonTest/kotlin/unsigned/u16_test.kt
new file mode 100644
index 0000000..de85738
--- /dev/null
+++ b/src/commonTest/kotlin/unsigned/u16_test.kt
@@ -0,0 +1,146 @@
+package unsigned
+
+import uns.*
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class u16_test {
+
+    @Test
+    fun u16() {
+
+        U16(0xFFFF).v `==` 0xFFFF.us
+        U16(0b1111111111111111.us).v `==` 0xFFFF.us
+        U16("1111_1111_1111_1111", 2).v `==` 0xFFFF.us
+        U16("177'777", 8).v `==` 0xFFFF.us
+        U16("65'535").v `==` 0xFFFF.us
+        U16("FFFF", 16).v `==` 0xFFFF.us
+
+        var a = U16.MAX
+
+        a.bigInt `==` BigInt(0xFFFF)
+        a.f64 `==` 0xFFFF.f64
+        a.f64 `==` 65535.0
+        a.f `==` 0xFFFF.f
+        a.f `==` 65535f
+        a.L `==` 0xFFFFL
+        a.L `==` 65535L
+        a.i `==` 0xFFFF
+        a.i `==` 65535
+        a.i.toChar() `==` 0xFFFF.toChar()
+        a.i16 `==` 0xFFFF.i16
+        a.i16 `==` 65535.toShort()
+
+        a.ub `==` U8(0xFFFF).v
+        a.ui `==` U32(0xFFFF).v
+        a.ul `==` U64(0xFFFF).v
+
+        var b = U16(1)
+        var c = U16(0)
+
+        assertTrue { a > b && b > c }
+
+        a + b `==` c
+        a + 1.us `==` c
+        a + 1 `==` 65535 + 1
+
+        c = U16(0xFFFE)
+
+        a - b `==` c
+        a - 1.us `==` c
+        a - 1 `==` c.i
+
+        a = U16(30_000)
+        b = U16(2)
+        c = U16(60_000)
+
+        a * b `==` c
+        a * 2.us `==` c
+        a * 2 `==` c.i
+
+        c / b `==` a
+        c / 2.us `==` a
+        c / 2.ui `==` a.ui
+
+        b = U16(50_000)
+        c = U16(20_000)
+
+        b % a `==` c
+        b % 30000.us `==` c
+        b % 30000.ui `==` c.ui
+
+        a = U16(0b1010_1010__1010_1010)
+        b = U16(0b0000_1111__0000_1111)
+        c = U16(0b0000_1010__0000_1010)
+
+        a and b `==` c
+        a and 0b0000_1111__0000_1111.us `==` c
+        a and 3_855 `==` c
+
+        c = U16(0b1010111110101111)
+
+        a or b `==` c
+        a or 0b1010_1111__1010_1111.us `==` c
+        a or 44_975 `==` c
+
+        c = U16(0b1010_0101__1010_0101)
+
+        a xor b `==` c
+        a xor 0b0000_1111__0000_1111.us `==` c
+        a xor 3855 `==` c
+
+        a = U16(0b0100_1100__0011_1101)
+        b = U16(8)
+        c = U16(0b0011_1101__0000_0000)
+
+        a shl b `==` c
+        a shl 8.us `==` c
+        a shl 8 `==` c
+
+        c = U16(0b0000_0000__0100_1100)
+
+        a shr b `==` c
+        a shr 8.us `==` c
+        a shr 8.ui `==` c
+
+        b = U16(0b1011_0011__1100_0010)
+
+        a.inv() `==` b
+
+        a = U16(65_500)
+
+        a compareTo U16(65_499) `==` 1
+        a compareTo 65499.us `==` 1
+        a compareTo 65499.ui `==` 1
+        a compareTo a `==` 0
+        a compareTo 65500.us `==` 0
+        a compareTo 65500.ui `==` 0
+
+        0xFFFF.i16 + U16(1) `==` 0.u16
+        0xFFFF.i16 - U16(1) `==` 0xFFFE.u16
+        30_000.i16 * U16(2) `==` 60_000.u16
+        60_000.us / U16(2) `==` 30_000.u16
+        65_000.us % U16(10_000) `==` 5_000.u16
+        0b1010_1010__1010_1010.i16 and U16(0b0000_1111__0000_1111) `==` 0b0000_1010__0000_1010.i16
+        0b1010_1010__1010_1010.i16 or U16(0b0000_1111__0000_1111) `==` 0b1010_1111__1010_1111.i16
+        0b1010_1010__1010_1010.i16 xor U16(0b0000_1111__0000_1111) `==` 0b1010_0101_1010_0101.i16
+        0b0100_1100__0011_1101.i16 shl U16(8) `==` 0b0011_1101__0000_0000.i16
+        0b0100_1100__0011_1101.i16 shr U16(8) `==` 0b0000_0000__0100_1100.i16
+        //        0b0100_1100__0011_1101.us.inv() `==` 0b1011_0011__1100_0010.us
+        65_500.us compareTo U16(65_499) `==` 1
+        65_500.us compareTo U16(65_500) `==` 0
+
+        0xFFFF + U16(1) `==` 0b1000_0000__0000_00000
+        0xFFFF - U16(1) `==` 0xFFFE
+        30_000 * U16(2) `==` 60_000
+        60_000.us / U16(2) `==` 30_000.u16
+        65_000.us % U16(10_000) `==` 5_000.u16
+        0b1010_1010__1010_1010 and U16(0b0000_1111__0000_1111) `==` 0b0000_1010__0000_1010
+        0b1010_1010__1010_1010 or U16(0b0000_1111__0000_1111) `==` 0b1010_1111__1010_1111
+        0b1010_1010__1010_1010 xor U16(0b0000_1111__0000_1111) `==` 0b1010_0101__1010_0101
+        0b0100_1100__0011_1101 shl U16(8) `==` 0b0100_1100__0011_1101__0000_0000
+        0b0100_1100__0011_1101 shr U16(8) `==` 0b100_1100
+        65_500.us compareTo U16(65_499) `==` 1
+        65_500.us compareTo U16(65_500) `==` 0
+    }
+}
\ No newline at end of file
diff --git a/src/commonTest/kotlin/unsigned/u32_test.kt b/src/commonTest/kotlin/unsigned/u32_test.kt
new file mode 100644
index 0000000..16b30a2
--- /dev/null
+++ b/src/commonTest/kotlin/unsigned/u32_test.kt
@@ -0,0 +1,133 @@
+package unsigned
+
+import uns.*
+import kotlin.test.Test
+
+class u32_test {
+
+    @Test
+    fun u16() {
+
+        /**
+         * BUG, 0xFFFFFFFF is interpreted as Long
+         * https://youtrack.jetbrains.com/issue/KT-2780
+         * https://youtrack.jetbrains.com/issue/KT-4749
+         */
+
+        U32(0xFFFF_FFFF).v `==` 0xFFFF_FFFFu
+        U32("11111111_11111111_11111111_11111111", 2).v `==` 0xFFFF_FFFFu
+        U32("37'777'777'777", 8).v `==` 0xFFFF_FFFFu
+        U32("4'294'967'295").v `==` 0xFFFF_FFFFu
+        U32("FFFFFFFF", 16).v `==` 0xFFFF_FFFFu
+
+        var a = U32(0xFFFF_FFFF)
+
+        a.bigInt `==` BigInt(0xFFFF_FFFF)
+        a.f64 `==` 0xFFFF_FFFF.f64
+        a.f `==` 0xFFFF_FFFF.f
+        a.L `==` 0xFFFF_FFFF // this is automatically interpreted as Long
+        a.i `==` 0xFFFF_FFFF.i
+        a.i.toChar() `==` 0xFFFF_FFFF.i.toChar()
+        a.i16 `==` 0xFFFF_FFFF.i16
+        a.i8 `==` 0xFFFF_FFFF.i8
+
+        a.ub `==` U8(0xFFFF_FFFF).v
+        a.us `==` U16(0xFFFF_FFFF).v
+        a.ul `==` U64(0xFFFF_FFFF).v
+
+        var b = U32(1)
+        var c = U32(0)
+
+        a + b `==` c
+        a + 1 `==` c
+
+        c = U32(0xFFFF_FFFE)
+
+        a - b `==` c
+        a - 1 `==` c
+
+        // TODO underscore https://youtrack.jetbrains.com/issue/KT-2964
+
+        a = U32(2_000_000_000)
+        b = U32(2)
+        c = U32(4_000_000_000)
+
+        a * b `==` c
+        a * 2 `==` c
+
+        c / b `==` a
+        c / 2 `==` a
+
+        b = U32(2_750_000_000)
+        c = U32(750_000_000)
+
+        b % a `==` c
+        b % 2_000_000_000 `==` c
+
+        a = U32(0b1010_1010__1010_1010__1010_1010__1010_1010)
+        b = U32(0b0000_1111__0000_1111__0000_1111__0000_1111)
+        c = U32(0b0000_1010__0000_1010__0000_1010__0000_1010)
+
+        a and b `==` c
+        a and 0b0000_1111__0000_1111__0000_1111__0000_1111 `==` c
+
+        c = U32(0b1010_1111__1010_1111__1010_1111__1010_1111)
+
+        a or b `==` c
+        a or 0b1010_1111__1010_1111__1010_1111__1010_1111.i `==` c
+
+        c = U32(0b1010_0101__1010_0101__1010_0101__1010_0101)
+
+        a xor b `==` c
+        a xor 0b0000_1111__0000_1111__0000_1111__0000_1111 `==` c
+
+        a = U32(0b0100_1100__0111_0000__1111_0000__0111_1101)
+        b = U32(16)
+        c = U32(0b1111_0000__0111_1101__0000_0000__0000_0000)
+
+        a shl b `==` c
+        a shl 16 `==` c
+
+        c = U32(0b0000_0000__0000_0000__0100_1100__0111_0000)
+
+        a shr b `==` c
+        a shr 16 `==` c
+
+        b = U32(0b1011_0011__1000_1111__0000_1111__1000_0010)
+
+        a.inv() `==` b
+
+        a = U32(2_000_000_000)
+
+        a compareTo U32(2_000_000_000 - 1) `==` 1
+        a compareTo (2_000_000_000u - 1u) `==` 1
+        a compareTo a `==` 0
+        a compareTo 2_000_000_000u `==` 0
+        a compareTo 2_000_000_000.ui `==` 0
+
+        0xFFFF_FFFF.i + U32(1) `==` 0.u32
+        0xFFFF_FFFF.i - U32(1) `==` 0xFFFF_FFFE.u32
+        2_000_000_000 * U32(2) `==` 4_000_000_000.u32
+        4_000_000_000.i / U32(2) `==` 2_000_000_000.u32
+        3_750_000_000.i % U32(1000000000) `==` 750_000_000.u32
+
+        val d = 0b0100_1100__0111_0000__1111_0000__0111_1101
+        val e = 0b0101_0101__0101_0101__0101_0101__0101_0101
+        // 0b01001100011100001111000001111101
+        // 0b01010101010101010101010101010101
+        // 0b01000100010100000101000001010101
+        d and U32(e) `==` 0b0100_0100__0101_0000__0101_0000__0101_0101
+        // 0b01001100011100001111000001111101
+        // 0b01010101010101010101010101010101
+        // 0b01011101011101011111010101111101
+        d or U32(e) `==` 0b0101_1101__0111_0101__1111_0101__0111_1101
+        // 0b01001100011100001111000001111101
+        // 0b01010101010101010101010101010101
+        // 0b00011001001001011010010100101000
+        d xor U32(e) `==` 0b0001_1001__0010_0101__1010_0101__0010_1000
+        d shl U32(16) `==` 0b1111_0000__0111_1101__0000_0000__0000_0000.i
+        d shr U32(16) `==` 0b0000_0000__0000_0000__0100_1100__0111_0000
+        d.ui compareTo U32(d - 1) `==` 1
+        d.ui compareTo U32(d) `==` 0
+    }
+}
\ No newline at end of file
diff --git a/src/commonTest/kotlin/unsigned/u8_test.kt b/src/commonTest/kotlin/unsigned/u8_test.kt
new file mode 100644
index 0000000..94e7843
--- /dev/null
+++ b/src/commonTest/kotlin/unsigned/u8_test.kt
@@ -0,0 +1,147 @@
+package unsigned
+
+import uns.*
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class u8_test() {
+
+    @Test
+    fun u8() {
+
+        U8(0xFF).v `==` 0xFF.ub
+        U8(0b11111111.i8).v `==` 0xFF.ub
+        U8("1111_1111", 2).v `==` 0xFF.ub
+        U8("377", 8).v `==` 0xFF.ub
+        U8("255").v `==` 0xFF.ub
+        U8("FF", 16).v `==` 0xFF.ub
+
+        var a = U8.MAX
+
+        a.bigInt `==` BigInt(0xFF)
+        a.f64 `==` 0xFF.f64
+        a.f64 `==` 255.0
+        a.f `==` 0xFF.f
+        a.f `==` 255f
+        a.L `==` 0xFF.L
+        a.L `==` 255L
+        a.i `==` 0xFF
+        a.i `==` 255
+        a.i.toChar() `==` 0xFF.toChar()
+        a.i16 `==` 0xFF.i16
+        a.i16 `==` 255.toShort()
+        a.i8 `==` 0xFF.i8
+        a.i8 `==` 255.toByte()
+
+        a.us `==` U16(0xFF).v
+        a.ui `==` U32(0xFF).v
+        a.ul `==` U64(0xFF).v
+
+        var b = U8(1)
+        var c = U8(0)
+
+        assertTrue { a > b && b > c}
+
+        a + b `==` c
+        a + 1.i8 `==` c
+        a + 1 `==` 255 + 1
+
+        c = U8(0xFE)
+
+        a - b `==` c
+        a - 1.i8 `==` c
+        a - 1 `==` c.i
+
+        a = U8(100)
+        b = U8(2)
+        c = U8(200)
+
+        a * b `==` c
+        a * 2.i8 `==` c
+        a * 2 `==` c.i
+
+        c / b `==` a
+        c / 2.i8 `==` a
+        c / 2 `==` a.i
+
+        b = U8(175)
+        c = U8(75)
+
+        b % a `==` c
+        b % 100.i8 `==` c
+        b % 100 `==` c.i
+
+        a = U8(0b1010_1010)
+        b = U8(0b0000_1111)
+        c = U8(0b0000_1010)
+
+        a and b `==` c
+        a and 15.i8 `==` c
+        a and 15 `==` c
+
+        c = U8(0b1010_1111)
+
+        a or b `==` c
+        a or 175.i8 `==` c
+        a or 175 `==` c
+
+        c = U8(0b1010_0101)
+
+        a xor b `==` c
+        a xor 15.i8 `==` c
+        a xor 15 `==` c
+
+        b = U8(4)
+        c = U8(0b1010_0000)
+
+        a shl b `==` c
+        a shl 4.i8 `==` c
+        a shl 4 `==` c
+
+        c = U8(0b0000_1010)
+
+        a shr b `==` c
+        a shr 4.i8 `==` c
+        a shr 4 `==` c
+
+        b = U8(0b0101_0101)
+
+        a.inv() `==` b
+
+        a = U8(250)
+
+        a compareTo U8(249) `==` 1
+        a compareTo 249.ub `==` 1
+        a compareTo 249.ui `==` 1
+        a compareTo a `==` 0
+        a compareTo 250.ub `==` 0
+        a compareTo 250.ui `==` 0
+
+        0xFF.i8 + U8(1) `==` 0.u8
+        0xFF.i8 - U8(1) `==` 0xFE.u8
+        100.i8 * U8(2) `==` 200.u8
+        200.i8 / U8(2) `==` 100.u8
+        175.i8 % U8(100) `==` 75.u8
+        0b1010_1010.i8 and U8(0b0000_1111) `==` 0b1010.i8
+        0b1010_1010.i8 or U8(0b0000_1111) `==` 0b1010_1111.i8
+        0b1010_1010.i8 xor U8(0b0000_1111) `==` 0b1010_0101.i8
+        0b1010_1010.i8 shl U8(4) `==` 0b1010_0000.i8
+        0b1010_1010.i8 shr U8(4) `==` 0b1010.i8
+//        0b1010_1010.i8.inv() `==` 0b0101_0101.ub
+        200.ub compareTo U8(199) `==` 1
+        200.ub compareTo U8(200) `==` 0
+
+        0xFF + U8(1) `==` 0b1_0000_0000
+        0xFF - U8(1) `==` 0xFE
+        100 * U8(2) `==` 200
+        200 / U8(2) `==` 100
+        175 % U8(100) `==` 75
+        0b1010_1010 and U8(0b0000_1111) `==` 0b1010
+        0b1010_1010 or U8(0b0000_1111) `==` 0b1010_1111
+        0b1010_1010 xor U8(0b0000_1111) `==` 0b1010_0101
+        0b1010_1010 shl U8(4) `==` 0b1010_1010_0000
+        0b1010_1010 shr U8(4) `==` 0b1010
+        200.ub compareTo U8(199) `==` 1
+        200.ub compareTo U8(200) `==` 0
+    }
+}
\ No newline at end of file
diff --git a/src/commonTest/kotlin/unsigned/ulong.kt b/src/commonTest/kotlin/unsigned/ulong.kt
new file mode 100644
index 0000000..e118269
--- /dev/null
+++ b/src/commonTest/kotlin/unsigned/ulong.kt
@@ -0,0 +1,126 @@
+package unsigned
+
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+import uns.*
+import kotlin.test.Test
+
+
+class u64_test {
+
+    @Test
+    fun u64() {
+
+        val max = 0xFFFF_FFFF_FFFF_FFFFu
+
+        U64(ULong.MAX_VALUE).v `==` max
+        U64("11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111111", 2).v `==` max
+        U64("1'777'777'777'777'777'777'777", 8).v `==` max
+        U64("18446744073709551615").v `==` max
+        U64("FFFF_FFFF_FFFF_FFFF", 16).v `==` max
+
+        var a = U64(ULong.MAX_VALUE)
+
+        a.bigInt `==` max.toBigInteger()
+        a.f64 `==` max.toBigInteger().f64
+        a.f `==` max.toBigInteger().f
+        a.ul `==` max
+        a.i `==` max.i
+        a.i.toChar() `==` max.i.toChar()
+        a.i16 `==` max.i16
+        a.i8 `==` max.i8
+
+        a.ub `==` U8(max).v
+        a.us `==` U16(max).v
+        a.ui `==` U32(max).v
+
+        var b = U64(1)
+        var c = U64(0)
+
+        a + b `==` c
+        a + 1 `==` c
+
+        c = U64(0xFFFF_FFFF__FFFF_FFFEu)
+
+        a - b `==` c
+        a - 1 `==` c
+
+        // BUG underscore https://youtrack.jetbrains.com/issue/KT-2964
+
+        a = U64(9_000_000_000_000_000_000)
+        b = U64(2)
+        c = U64(18_000_000_000_000_000_000u)
+
+        a * b `==` c
+        a * 2 `==` c
+
+        c / b `==` a
+        c / 2 `==` a
+
+        b = U64(17_000_000_000_000_000_000u)
+        c = U64(8_000_000_000_000_000_000)
+
+        b % a `==` c
+        b % 9_000_000_000_000_000_000 `==` c
+
+        a = U64(0b1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010u)
+        b = U64(0b0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111)
+        c = U64(0b0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010)
+
+        a and b `==` c
+        a and 0b0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111 `==` c
+
+        // 1010101010101010101010101010101010101010101010101010101010101010
+        // 0000111100001111000011110000111100001111000011110000111100001111
+        // 1010111110101111101011111010111110101111101011111010111110101111
+        c = U64(0b1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111u)
+
+        a or b `==` c
+        a or 0b1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111u `==` c
+
+        c = U64(0b1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101u)
+
+        a xor b `==` c
+        a xor 0b0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111 `==` c
+
+        a = U64(0b0100_1100__0111_0000__1111_0000__0111_1100__0000_1111__1100_0000__0111_1111__0000_0000)
+        b = U64(32)
+        c = U64(0b0000_1111__1100_0000__0111_1111__0000_0000__0000_0000__0000_0000__0000_0000__0000_0000)
+
+        a shl b.toInt() `==` c
+        a shl 32 `==` c
+
+        c = U64(0b0000_0000__0000_0000__0000_0000__0000_0000__0100_1100__0111_0000__1111_0000__0111_1100)
+
+        a shr b.toInt() `==` c
+        a shr 32 `==` c
+
+        b = U64(0b1011_0011__1000_1111__0000_1111__1000_0011__1111_0000__0011_1111__1000_0000__1111_1111u)
+
+        a.inv() `==` b
+
+        a = U64("18'000'000'000'000'000'000")
+
+        a compareTo U64("17'999'999'999'999'999'999") `==` 1
+        a compareTo 17_999_999_999_999_999_999u `==` 1
+        a compareTo a `==` 0
+        a compareTo 18_000_000_000_000_000_000u `==` 0
+
+        0xFFFF_FFFF__FFFF_FFFFuL + 1.u64 `==` 0.u64
+        0xFFFF_FFFF__FFFF_FFFFuL - 1.u64 `==` 0xFFFF_FFFF__FFFF_FFFEu.u64
+        9_000_000_000_000_000_000L * 2.u64 `==` 18_000_000_000_000_000_000u.u64
+        18_000_000_000_000_000_000uL / 2.u64 `==` 9_000_000_000_000_000_000.u64
+        17_000_000_000_000_000_000uL % 9_000_000_000_000_000_000.u64 `==` 8_000_000_000_000_000_000.u64
+
+        var d = 0b1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010uL
+        val e = 0b0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111uL.u64
+
+        d and e `==` 0b0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010u
+        d or e `==` 0b1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111u
+        d xor e `==` 0b1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101u
+        d = 0b0100_1100__0111_0000__1111_0000__0111_1100__0000_1111__1100_0000__0111_1111__0000_0000uL
+        d shl U64(32) `==` 0b0000_1111__1100_0000__0111_1111__0000_0000__0000_0000__0000_0000__0000_0000__0000_0000u
+        d shr U64(32) `==` 0b0000_0000__0000_0000__0000_0000__0000_0000__0100_1100__0111_0000__1111_0000__0111_1100u
+        d compareTo U64(0b1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1011u) `==` -1
+        d compareTo U64(d) `==` 0
+    }
+}
\ No newline at end of file
diff --git a/src/commonTest/kotlin/unsigned/utils.kt b/src/commonTest/kotlin/unsigned/utils.kt
new file mode 100644
index 0000000..3246579
--- /dev/null
+++ b/src/commonTest/kotlin/unsigned/utils.kt
@@ -0,0 +1,5 @@
+package unsigned
+
+import kotlin.test.assertEquals
+
+infix fun <T> T.`==`(other: T) = assertEquals(other, this)
\ No newline at end of file
diff --git a/src/genCommonMain/kotlin/uns/U16.kt b/src/genCommonMain/kotlin/uns/U16.kt
new file mode 100644
index 0000000..20ee793
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/U16.kt
@@ -0,0 +1,364 @@
+@file:Suppress("NOTHING_TO_INLINE")
+package uns
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+import uns.format.format
+import uns.U8
+import kotlin.experimental.inv
+import kotlin.experimental.or
+import kotlin.experimental.and
+import uns.U32
+import uns.U64
+import kotlin.experimental.xor
+import uns.BigInt
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+
+inline fun U16(byte: Byte): U16 = U16(byte.toUByte())
+inline fun U16(short: Short): U16 = U16(short.toUShort())
+inline fun U16(int: Int): U16 = U16(int.toUInt())
+inline fun U16(long: Long): U16 = U16(long.toULong())
+class U16(var v: UShort = MIN.v) : Number(), Comparable<U16> {
+	companion object {
+		/** A uint constant holding the minimum value an `unsigned short` can have, 0. */
+		val MIN_uint: UInt = 0u
+		
+		/** A uint constant holding the maximum value an `unsigned short` can have, 2^16-1. */
+		val MAX_uint: UInt = 0xFFFFu
+		
+		/** A constant holding the minimum value an `unsigned short` can have, 0.  */
+		val MIN = U16(UShort.MIN_VALUE)
+		
+		/** A constant holding the maximum value an `unsigned short` can have, 2^16-1. */
+		val MAX = U16(UShort.MAX_VALUE)
+		
+		/** The number of bytes used to represent an instance of UByte in a binary form. */
+		const val SIZE_BYTES: Int = UShort.SIZE_BYTES
+		
+		/** The number of bits used to represent an instance of UByte in a binary form. */
+		const val SIZE_BITS: Int = UShort.SIZE_BITS
+	}
+	constructor(u8: U8) : this(u8.toUShort())
+	constructor(u16: U16) : this(u16.v)
+	constructor(u32: U32) : this(u32.toUShort())
+	constructor(u64: U64) : this(u64.toUShort())
+	constructor(bigint: BigInt, exactRequired: Boolean = true) : this(bigint.ushortValue(exactRequired))
+	constructor(ubyte: UByte) : this(ubyte.toUShort())
+	constructor(uint: UInt) : this(uint.toUShort())
+	constructor(ulong: ULong) : this(ulong.toUShort())
+	constructor(string: String, radix: Int = 10) : this(string.filter { it != '_' && it != '\'' }.toUShort(radix))
+	override fun toByte(): Byte = v.toByte()
+	override fun toShort(): Short = v.toShort()
+	override fun toInt(): Int = v.toInt()
+	override fun toLong(): Long = v.toLong()
+	inline fun toU8(): U8 = U8(v)
+	inline fun toU16(): U16 = U16(v)
+	inline fun toU32(): U32 = U32(v)
+	inline fun toU64(): U64 = U64(v)
+	inline fun toBigInt(): BigInt = v.toBigInteger()
+	override fun toFloat(): Float = v.toFloat()
+	override fun toDouble(): Double = v.toDouble()
+	inline fun toUByte(): UByte = v.toUByte()
+	inline fun toUShort(): UShort = v
+	inline fun toUInt(): UInt = v.toUInt()
+	inline fun toULong(): ULong = v.toULong()
+	@Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+	override fun toChar() = toInt().toChar()
+	inline fun copy(): U16 = toU16()
+	inline operator fun inc(): U16 = U16(v.inc())
+	inline operator fun dec(): U16 = U16(v.dec())
+	infix inline operator fun plus(b: Byte): U16 = U16(v + b.toUByte().toUShort())
+	infix inline operator fun plus(b: Short): U16 = U16(v + b.toUShort())
+	infix inline operator fun plus(b: Int): Int = v.toInt() + b
+	infix inline operator fun plus(b: Long): Long = v.toLong() + b
+	infix inline operator fun plus(b: U8): U16 = U16(v + b.v)
+	infix inline operator fun plus(b: U16): U16 = U16(v + b.v)
+	infix inline operator fun plus(b: U32): U32 = U32(v.toUInt() + b.v)
+	infix inline operator fun plus(b: U64): U64 = U64(v.toULong() + b.v)
+	infix inline operator fun plus(b: BigInt): BigInt = v.toBigInteger() + b
+	infix inline operator fun plus(b: Float): Float = v.toFloat() + b
+	infix inline operator fun plus(b: Double): Double = v.toDouble() + b
+	infix inline operator fun plus(b: UByte): U16 = U16(v + b)
+	infix inline operator fun plus(b: UShort): U16 = U16(v + b)
+	infix inline operator fun plus(b: UInt): UInt = v.toUInt() + b
+	infix inline operator fun plus(b: ULong): ULong = v.toULong() + b
+	infix inline operator fun minus(b: Byte): U16 = U16(v - b.toUByte().toUShort())
+	infix inline operator fun minus(b: Short): U16 = U16(v - b.toUShort())
+	infix inline operator fun minus(b: Int): Int = v.toInt() - b
+	infix inline operator fun minus(b: Long): Long = v.toLong() - b
+	infix inline operator fun minus(b: U8): U16 = U16(v - b.v)
+	infix inline operator fun minus(b: U16): U16 = U16(v - b.v)
+	infix inline operator fun minus(b: U32): U32 = U32(v.toUInt() - b.v)
+	infix inline operator fun minus(b: U64): U64 = U64(v.toULong() - b.v)
+	infix inline operator fun minus(b: BigInt): BigInt = v.toBigInteger() - b
+	infix inline operator fun minus(b: Float): Float = v.toFloat() - b
+	infix inline operator fun minus(b: Double): Double = v.toDouble() - b
+	infix inline operator fun minus(b: UByte): U16 = U16(v - b)
+	infix inline operator fun minus(b: UShort): U16 = U16(v - b)
+	infix inline operator fun minus(b: UInt): UInt = v.toUInt() - b
+	infix inline operator fun minus(b: ULong): ULong = v.toULong() - b
+	infix inline operator fun times(b: Byte): U16 = U16(v * b.toUByte().toUShort())
+	infix inline operator fun times(b: Short): U16 = U16(v * b.toUShort())
+	infix inline operator fun times(b: Int): Int = v.toInt() * b
+	infix inline operator fun times(b: Long): Long = v.toLong() * b
+	infix inline operator fun times(b: U8): U16 = U16(v * b.v)
+	infix inline operator fun times(b: U16): U16 = U16(v * b.v)
+	infix inline operator fun times(b: U32): U32 = U32(v.toUInt() * b.v)
+	infix inline operator fun times(b: U64): U64 = U64(v.toULong() * b.v)
+	infix inline operator fun times(b: BigInt): BigInt = v.toBigInteger() * b
+	infix inline operator fun times(b: Float): Float = v.toFloat() * b
+	infix inline operator fun times(b: Double): Double = v.toDouble() * b
+	infix inline operator fun times(b: UByte): U16 = U16(v * b)
+	infix inline operator fun times(b: UShort): U16 = U16(v * b)
+	infix inline operator fun times(b: UInt): UInt = v.toUInt() * b
+	infix inline operator fun times(b: ULong): ULong = v.toULong() * b
+	infix inline operator fun div(b: Byte): U16 = U16(v / b.toUByte().toUShort())
+	infix inline operator fun div(b: Short): U16 = U16(v / b.toUShort())
+	infix inline operator fun div(b: Int): Int = v.toInt() / b
+	infix inline operator fun div(b: Long): Long = v.toLong() / b
+	infix inline operator fun div(b: U8): U16 = U16(v / b.v)
+	infix inline operator fun div(b: U16): U16 = U16(v / b.v)
+	infix inline operator fun div(b: U32): U32 = U32(v.toUInt() / b.v)
+	infix inline operator fun div(b: U64): U64 = U64(v.toULong() / b.v)
+	infix inline operator fun div(b: BigInt): BigInt = v.toBigInteger() / b
+	infix inline operator fun div(b: Float): Float = v.toFloat() / b
+	infix inline operator fun div(b: Double): Double = v.toDouble() / b
+	infix inline operator fun div(b: UByte): U16 = U16(v / b)
+	infix inline operator fun div(b: UShort): U16 = U16(v / b)
+	infix inline operator fun div(b: UInt): UInt = v.toUInt() / b
+	infix inline operator fun div(b: ULong): ULong = v.toULong() / b
+	infix inline operator fun rem(b: Byte): U16 = U16(v % b.toUByte().toUShort())
+	infix inline operator fun rem(b: Short): U16 = U16(v % b.toUShort())
+	infix inline operator fun rem(b: Int): Int = v.toInt() % b
+	infix inline operator fun rem(b: Long): Long = v.toLong() % b
+	infix inline operator fun rem(b: U8): U16 = U16(v % b.v)
+	infix inline operator fun rem(b: U16): U16 = U16(v % b.v)
+	infix inline operator fun rem(b: U32): U32 = U32(v.toUInt() % b.v)
+	infix inline operator fun rem(b: U64): U64 = U64(v.toULong() % b.v)
+	infix inline operator fun rem(b: BigInt): BigInt = v.toBigInteger() % b
+	infix inline operator fun rem(b: Float): Float = v.toFloat() % b
+	infix inline operator fun rem(b: Double): Double = v.toDouble() % b
+	infix inline operator fun rem(b: UByte): U16 = U16(v % b)
+	infix inline operator fun rem(b: UShort): U16 = U16(v % b)
+	infix inline operator fun rem(b: UInt): UInt = v.toUInt() % b
+	infix inline operator fun rem(b: ULong): ULong = v.toULong() % b
+	inline operator fun plusAssign(b: Byte) { v = (v + b.toUByte().toUShort()).toUShort() }
+	inline operator fun plusAssign(b: Short) { v = (v + b.toUShort()).toUShort() }
+	inline operator fun plusAssign(b: Int) { v = (v.toInt() + b).toUShort() }
+	inline operator fun plusAssign(b: Long) { v = (v.toLong() + b).toUShort() }
+	inline operator fun plusAssign(b: U8) { v = (v + b.v).toUShort() }
+	inline operator fun plusAssign(b: U16) { v = (v + b.v).toUShort() }
+	inline operator fun plusAssign(b: U32) { v = (v.toUInt() + b.v).toUShort() }
+	inline operator fun plusAssign(b: U64) { v = (v.toULong() + b.v).toUShort() }
+	inline operator fun plusAssign(b: BigInt) { v = (v.toBigInteger() + b).ushortValue() }
+	inline operator fun plusAssign(b: Float) { v = (v.toFloat() + b).toInt().toUShort() }
+	inline operator fun plusAssign(b: Double) { v = (v.toDouble() + b).toInt().toUShort() }
+	inline operator fun plusAssign(b: UByte) { v = (v + b).toUShort() }
+	inline operator fun plusAssign(b: UShort) { v = (v + b).toUShort() }
+	inline operator fun plusAssign(b: UInt) { v = (v.toUInt() + b).toUShort() }
+	inline operator fun plusAssign(b: ULong) { v = (v.toULong() + b).toUShort() }
+	inline operator fun minusAssign(b: Byte) { v = (v - b.toUByte().toUShort()).toUShort() }
+	inline operator fun minusAssign(b: Short) { v = (v - b.toUShort()).toUShort() }
+	inline operator fun minusAssign(b: Int) { v = (v.toInt() - b).toUShort() }
+	inline operator fun minusAssign(b: Long) { v = (v.toLong() - b).toUShort() }
+	inline operator fun minusAssign(b: U8) { v = (v - b.v).toUShort() }
+	inline operator fun minusAssign(b: U16) { v = (v - b.v).toUShort() }
+	inline operator fun minusAssign(b: U32) { v = (v.toUInt() - b.v).toUShort() }
+	inline operator fun minusAssign(b: U64) { v = (v.toULong() - b.v).toUShort() }
+	inline operator fun minusAssign(b: BigInt) { v = (v.toBigInteger() - b).ushortValue() }
+	inline operator fun minusAssign(b: Float) { v = (v.toFloat() - b).toInt().toUShort() }
+	inline operator fun minusAssign(b: Double) { v = (v.toDouble() - b).toInt().toUShort() }
+	inline operator fun minusAssign(b: UByte) { v = (v - b).toUShort() }
+	inline operator fun minusAssign(b: UShort) { v = (v - b).toUShort() }
+	inline operator fun minusAssign(b: UInt) { v = (v.toUInt() - b).toUShort() }
+	inline operator fun minusAssign(b: ULong) { v = (v.toULong() - b).toUShort() }
+	inline operator fun timesAssign(b: Byte) { v = (v * b.toUByte().toUShort()).toUShort() }
+	inline operator fun timesAssign(b: Short) { v = (v * b.toUShort()).toUShort() }
+	inline operator fun timesAssign(b: Int) { v = (v.toInt() * b).toUShort() }
+	inline operator fun timesAssign(b: Long) { v = (v.toLong() * b).toUShort() }
+	inline operator fun timesAssign(b: U8) { v = (v * b.v).toUShort() }
+	inline operator fun timesAssign(b: U16) { v = (v * b.v).toUShort() }
+	inline operator fun timesAssign(b: U32) { v = (v.toUInt() * b.v).toUShort() }
+	inline operator fun timesAssign(b: U64) { v = (v.toULong() * b.v).toUShort() }
+	inline operator fun timesAssign(b: BigInt) { v = (v.toBigInteger() * b).ushortValue() }
+	inline operator fun timesAssign(b: Float) { v = (v.toFloat() * b).toInt().toUShort() }
+	inline operator fun timesAssign(b: Double) { v = (v.toDouble() * b).toInt().toUShort() }
+	inline operator fun timesAssign(b: UByte) { v = (v * b).toUShort() }
+	inline operator fun timesAssign(b: UShort) { v = (v * b).toUShort() }
+	inline operator fun timesAssign(b: UInt) { v = (v.toUInt() * b).toUShort() }
+	inline operator fun timesAssign(b: ULong) { v = (v.toULong() * b).toUShort() }
+	inline operator fun divAssign(b: Byte) { v = (v / b.toUByte().toUShort()).toUShort() }
+	inline operator fun divAssign(b: Short) { v = (v / b.toUShort()).toUShort() }
+	inline operator fun divAssign(b: Int) { v = (v.toInt() / b).toUShort() }
+	inline operator fun divAssign(b: Long) { v = (v.toLong() / b).toUShort() }
+	inline operator fun divAssign(b: U8) { v = (v / b.v).toUShort() }
+	inline operator fun divAssign(b: U16) { v = (v / b.v).toUShort() }
+	inline operator fun divAssign(b: U32) { v = (v.toUInt() / b.v).toUShort() }
+	inline operator fun divAssign(b: U64) { v = (v.toULong() / b.v).toUShort() }
+	inline operator fun divAssign(b: BigInt) { v = (v.toBigInteger() / b).ushortValue() }
+	inline operator fun divAssign(b: Float) { v = (v.toFloat() / b).toInt().toUShort() }
+	inline operator fun divAssign(b: Double) { v = (v.toDouble() / b).toInt().toUShort() }
+	inline operator fun divAssign(b: UByte) { v = (v / b).toUShort() }
+	inline operator fun divAssign(b: UShort) { v = (v / b).toUShort() }
+	inline operator fun divAssign(b: UInt) { v = (v.toUInt() / b).toUShort() }
+	inline operator fun divAssign(b: ULong) { v = (v.toULong() / b).toUShort() }
+	inline operator fun remAssign(b: Byte) { v = (v % b.toUByte().toUShort()).toUShort() }
+	inline operator fun remAssign(b: Short) { v = (v % b.toUShort()).toUShort() }
+	inline operator fun remAssign(b: Int) { v = (v.toInt() % b).toUShort() }
+	inline operator fun remAssign(b: Long) { v = (v.toLong() % b).toUShort() }
+	inline operator fun remAssign(b: U8) { v = (v % b.v).toUShort() }
+	inline operator fun remAssign(b: U16) { v = (v % b.v).toUShort() }
+	inline operator fun remAssign(b: U32) { v = (v.toUInt() % b.v).toUShort() }
+	inline operator fun remAssign(b: U64) { v = (v.toULong() % b.v).toUShort() }
+	inline operator fun remAssign(b: BigInt) { v = (v.toBigInteger() % b).ushortValue() }
+	inline operator fun remAssign(b: Float) { v = (v.toFloat() % b).toInt().toUShort() }
+	inline operator fun remAssign(b: Double) { v = (v.toDouble() % b).toInt().toUShort() }
+	inline operator fun remAssign(b: UByte) { v = (v % b).toUShort() }
+	inline operator fun remAssign(b: UShort) { v = (v % b).toUShort() }
+	inline operator fun remAssign(b: UInt) { v = (v.toUInt() % b).toUShort() }
+	inline operator fun remAssign(b: ULong) { v = (v.toULong() % b).toUShort() }
+	inline infix fun and(b: Byte): U16 = U16(v and b.toUByte().toUShort())
+	inline infix fun and(b: Short): U16 = U16(v and b.toUShort())
+	inline infix fun and(b: Int): U16 = U16(v and b.toUInt().toUShort())
+	inline infix fun and(b: Long): U16 = U16(v and b.toULong().toUShort())
+	inline infix fun and(b: U8): U16 = U16(v and b.v.toUShort())
+	inline infix fun and(b: U16): U16 = U16(v and b.v)
+	inline infix fun and(b: U32): U16 = U16(v and b.v.toUShort())
+	inline infix fun and(b: U64): U16 = U16(v and b.v.toUShort())
+	inline infix fun and(b: BigInt): U16 = U16(v and b.ushortValue())
+	inline infix fun and(b: UByte): U16 = U16(v and b.toUShort())
+	inline infix fun and(b: UShort): U16 = U16(v and b)
+	inline infix fun and(b: UInt): U16 = U16(v and b.toUShort())
+	inline infix fun and(b: ULong): U16 = U16(v and b.toUShort())
+	inline infix fun or(b: Byte): U16 = U16(v or b.toUByte().toUShort())
+	inline infix fun or(b: Short): U16 = U16(v or b.toUShort())
+	inline infix fun or(b: Int): U16 = U16(v or b.toUInt().toUShort())
+	inline infix fun or(b: Long): U16 = U16(v or b.toULong().toUShort())
+	inline infix fun or(b: U8): U16 = U16(v or b.v.toUShort())
+	inline infix fun or(b: U16): U16 = U16(v or b.v)
+	inline infix fun or(b: U32): U16 = U16(v or b.v.toUShort())
+	inline infix fun or(b: U64): U16 = U16(v or b.v.toUShort())
+	inline infix fun or(b: BigInt): U16 = U16(v or b.ushortValue())
+	inline infix fun or(b: UByte): U16 = U16(v or b.toUShort())
+	inline infix fun or(b: UShort): U16 = U16(v or b)
+	inline infix fun or(b: UInt): U16 = U16(v or b.toUShort())
+	inline infix fun or(b: ULong): U16 = U16(v or b.toUShort())
+	inline infix fun xor(b: Byte): U16 = U16(v xor b.toUByte().toUShort())
+	inline infix fun xor(b: Short): U16 = U16(v xor b.toUShort())
+	inline infix fun xor(b: Int): U16 = U16(v xor b.toUInt().toUShort())
+	inline infix fun xor(b: Long): U16 = U16(v xor b.toULong().toUShort())
+	inline infix fun xor(b: U8): U16 = U16(v xor b.v.toUShort())
+	inline infix fun xor(b: U16): U16 = U16(v xor b.v)
+	inline infix fun xor(b: U32): U16 = U16(v xor b.v.toUShort())
+	inline infix fun xor(b: U64): U16 = U16(v xor b.v.toUShort())
+	inline infix fun xor(b: BigInt): U16 = U16(v xor b.ushortValue())
+	inline infix fun xor(b: UByte): U16 = U16(v xor b.toUShort())
+	inline infix fun xor(b: UShort): U16 = U16(v xor b)
+	inline infix fun xor(b: UInt): U16 = U16(v xor b.toUShort())
+	inline infix fun xor(b: ULong): U16 = U16(v xor b.toUShort())
+	inline infix fun shl(b: Byte): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: Short): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: Int): U16 = U16(v.toUInt() shl b)
+	inline infix fun shl(b: Long): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: U8): U16 = U16(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: U16): U16 = U16(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: U32): U16 = U16(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: U64): U16 = U16(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: BigInt): U16 = U16(v.toUInt() shl b.intValue())
+	inline infix fun shl(b: UByte): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: UShort): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: UInt): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: ULong): U16 = U16(v.toUInt() shl b.toInt())
+	inline infix fun shr(b: Byte): U16 = U16(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: Short): U16 = U16(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: Int): U16 = U16(v.toUInt() shr b)
+	inline infix fun shr(b: Long): U16 = U16(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: U8): U16 = U16(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: U16): U16 = U16(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: U32): U16 = U16(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: U64): U16 = U16(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: BigInt): U16 = U16(v.toUInt() shr b.intValue())
+	inline infix fun shr(b: UByte): U16 = U16(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: UShort): U16 = U16(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: UInt): U16 = U16(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: ULong): U16 = U16(v.toUInt() shr b.toInt())
+	inline fun inv(): U16 = U16(v.inv())
+	inline infix fun andAssign(b: Byte) { v = v and b.toUShort() }
+	inline infix fun andAssign(b: Short) { v = v and b.toUShort() }
+	inline infix fun andAssign(b: Int) { v = v and b.toUShort() }
+	inline infix fun andAssign(b: Long) { v = v and b.toUShort() }
+	inline infix fun andAssign(b: U8) { v = v and b.v.toUShort() }
+	inline infix fun andAssign(b: U16) { v = v and b.v }
+	inline infix fun andAssign(b: U32) { v = v and b.v.toUShort() }
+	inline infix fun andAssign(b: U64) { v = v and b.v.toUShort() }
+	inline infix fun andAssign(b: BigInt) { v = v and b.ushortValue() }
+	inline infix fun andAssign(b: UByte) { v = v and b.toUShort() }
+	inline infix fun andAssign(b: UShort) { v = v and b }
+	inline infix fun andAssign(b: UInt) { v = v and b.toUShort() }
+	inline infix fun andAssign(b: ULong) { v = v and b.toUShort() }
+	inline infix fun orAssign(b: Byte) { v = v or b.toUShort() }
+	inline infix fun orAssign(b: Short) { v = v or b.toUShort() }
+	inline infix fun orAssign(b: Int) { v = v or b.toUShort() }
+	inline infix fun orAssign(b: Long) { v = v or b.toUShort() }
+	inline infix fun orAssign(b: U8) { v = v or b.v.toUShort() }
+	inline infix fun orAssign(b: U16) { v = v or b.v }
+	inline infix fun orAssign(b: U32) { v = v or b.v.toUShort() }
+	inline infix fun orAssign(b: U64) { v = v or b.v.toUShort() }
+	inline infix fun orAssign(b: BigInt) { v = v or b.ushortValue() }
+	inline infix fun orAssign(b: UByte) { v = v or b.toUShort() }
+	inline infix fun orAssign(b: UShort) { v = v or b }
+	inline infix fun orAssign(b: UInt) { v = v or b.toUShort() }
+	inline infix fun orAssign(b: ULong) { v = v or b.toUShort() }
+	inline infix fun xorAssign(b: Byte) { v = v xor b.toUShort() }
+	inline infix fun xorAssign(b: Short) { v = v xor b.toUShort() }
+	inline infix fun xorAssign(b: Int) { v = v xor b.toUShort() }
+	inline infix fun xorAssign(b: Long) { v = v xor b.toUShort() }
+	inline infix fun xorAssign(b: U8) { v = v xor b.v.toUShort() }
+	inline infix fun xorAssign(b: U16) { v = v xor b.v }
+	inline infix fun xorAssign(b: U32) { v = v xor b.v.toUShort() }
+	inline infix fun xorAssign(b: U64) { v = v xor b.v.toUShort() }
+	inline infix fun xorAssign(b: BigInt) { v = v xor b.ushortValue() }
+	inline infix fun xorAssign(b: UByte) { v = v xor b.toUShort() }
+	inline infix fun xorAssign(b: UShort) { v = v xor b }
+	inline infix fun xorAssign(b: UInt) { v = v xor b.toUShort() }
+	inline infix fun xorAssign(b: ULong) { v = v xor b.toUShort() }
+	inline infix fun shlAssign(b: Byte) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: Short) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: Int) { v = (v.toUInt() shl b).toUShort() }
+	inline infix fun shlAssign(b: Long) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: U8) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: U16) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: U32) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: U64) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: BigInt) { v = (v.toUInt() shl b.intValue()).toUShort() }
+	inline infix fun shlAssign(b: UByte) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: UShort) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: UInt) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shlAssign(b: ULong) { v = (v.toUInt() shl b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: Byte) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: Short) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: Int) { v = (v.toUInt() shr b).toUShort() }
+	inline infix fun shrAssign(b: Long) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: U8) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: U16) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: U32) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: U64) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: BigInt) { v = (v.toUInt() shr b.intValue()).toUShort() }
+	inline infix fun shrAssign(b: UByte) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: UShort) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: UInt) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline infix fun shrAssign(b: ULong) { v = (v.toUInt() shr b.toInt()).toUShort() }
+	inline fun invAssign() { v = v.inv() }
+	infix inline operator fun compareTo(other: U8): Int = toUByte().compareTo(other.v)
+	infix override operator fun compareTo(other: U16): Int = v.compareTo(other.v)
+	infix inline operator fun compareTo(other: U32): Int = toUInt().compareTo(other.v)
+	infix inline operator fun compareTo(other: U64): Int = toULong().compareTo(other.v)
+	infix inline operator fun compareTo(other: UByte): Int = toUByte().compareTo(other)
+	infix inline operator fun compareTo(other: UShort): Int = v.compareTo(other)
+	infix inline operator fun compareTo(other: UInt): Int = toUInt().compareTo(other)
+	infix inline operator fun compareTo(other: ULong): Int = toULong().compareTo(other)
+	override fun equals(other: Any?): Boolean = other is U16 && v == other.v
+	override fun hashCode(): Int = v.hashCode()
+	override fun toString(): String = v.toString()
+	inline fun toString(radix: Int): String = v.toString(radix)
+	inline fun toString(format: String): String = format.format(this)
+}
diff --git a/src/genCommonMain/kotlin/uns/U32.kt b/src/genCommonMain/kotlin/uns/U32.kt
new file mode 100644
index 0000000..665b0c1
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/U32.kt
@@ -0,0 +1,364 @@
+@file:Suppress("NOTHING_TO_INLINE")
+package uns
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+import uns.U16
+import uns.format.format
+import uns.U8
+import kotlin.experimental.inv
+import kotlin.experimental.or
+import kotlin.experimental.and
+import uns.U64
+import kotlin.experimental.xor
+import uns.BigInt
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+
+inline fun U32(byte: Byte): U32 = U32(byte.toUByte())
+inline fun U32(short: Short): U32 = U32(short.toUShort())
+inline fun U32(int: Int): U32 = U32(int.toUInt())
+inline fun U32(long: Long): U32 = U32(long.toULong())
+class U32(var v: UInt = MIN.v) : Number(), Comparable<U32> {
+	companion object {
+		/** A ulong constant holding the minimum value an `unsigned int` can have, 0. */
+		val MIN_ulong: ULong = 0uL
+		
+		/** A ulong constant holding the maximum value an `unsigned int` can have, 2^32-1. */
+		val MAX_ulong: ULong = 0xFFFF_FFFFuL
+		
+		/** A constant holding the minimum value an `unsigned int` can have, 0.  */
+		val MIN = U32(UInt.MIN_VALUE)
+		
+		/** A constant holding the maximum value an `unsigned int` can have, 2^32-1. */
+		val MAX = U32(UInt.MAX_VALUE)
+		
+		/** The number of bytes used to represent an instance of UByte in a binary form. */
+		const val SIZE_BYTES: Int = UInt.SIZE_BYTES
+		
+		/** The number of bits used to represent an instance of UByte in a binary form. */
+		const val SIZE_BITS: Int = UInt.SIZE_BITS
+	}
+	constructor(u8: U8) : this(u8.toUInt())
+	constructor(u16: U16) : this(u16.toUInt())
+	constructor(u32: U32) : this(u32.v)
+	constructor(u64: U64) : this(u64.toUInt())
+	constructor(bigint: BigInt, exactRequired: Boolean = true) : this(bigint.uintValue(exactRequired))
+	constructor(ubyte: UByte) : this(ubyte.toUInt())
+	constructor(ushort: UShort) : this(ushort.toUInt())
+	constructor(ulong: ULong) : this(ulong.toUInt())
+	constructor(string: String, radix: Int = 10) : this(string.filter { it != '_' && it != '\'' }.toUInt(radix))
+	override fun toByte(): Byte = v.toByte()
+	override fun toShort(): Short = v.toShort()
+	override fun toInt(): Int = v.toInt()
+	override fun toLong(): Long = v.toLong()
+	inline fun toU8(): U8 = U8(v)
+	inline fun toU16(): U16 = U16(v)
+	inline fun toU32(): U32 = U32(v)
+	inline fun toU64(): U64 = U64(v)
+	inline fun toBigInt(): BigInt = v.toBigInteger()
+	override fun toFloat(): Float = v.toFloat()
+	override fun toDouble(): Double = v.toDouble()
+	inline fun toUByte(): UByte = v.toUByte()
+	inline fun toUShort(): UShort = v.toUShort()
+	inline fun toUInt(): UInt = v
+	inline fun toULong(): ULong = v.toULong()
+	@Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+	override fun toChar() = toInt().toChar()
+	inline fun copy(): U32 = toU32()
+	inline operator fun inc(): U32 = U32(v.inc())
+	inline operator fun dec(): U32 = U32(v.dec())
+	infix inline operator fun plus(b: Byte): U32 = U32(v + b.toUByte().toUInt())
+	infix inline operator fun plus(b: Short): U32 = U32(v + b.toUShort().toUInt())
+	infix inline operator fun plus(b: Int): U32 = U32(v + b.toUInt())
+	infix inline operator fun plus(b: Long): Long = v.toLong() + b
+	infix inline operator fun plus(b: U8): U32 = U32(v + b.v)
+	infix inline operator fun plus(b: U16): U32 = U32(v + b.v)
+	infix inline operator fun plus(b: U32): U32 = U32(v + b.v)
+	infix inline operator fun plus(b: U64): U64 = U64(v.toULong() + b.v)
+	infix inline operator fun plus(b: BigInt): BigInt = v.toBigInteger() + b
+	infix inline operator fun plus(b: Float): Float = v.toFloat() + b
+	infix inline operator fun plus(b: Double): Double = v.toDouble() + b
+	infix inline operator fun plus(b: UByte): U32 = U32(v + b)
+	infix inline operator fun plus(b: UShort): U32 = U32(v + b)
+	infix inline operator fun plus(b: UInt): U32 = U32(v + b)
+	infix inline operator fun plus(b: ULong): ULong = v.toULong() + b
+	infix inline operator fun minus(b: Byte): U32 = U32(v - b.toUByte().toUInt())
+	infix inline operator fun minus(b: Short): U32 = U32(v - b.toUShort().toUInt())
+	infix inline operator fun minus(b: Int): U32 = U32(v - b.toUInt())
+	infix inline operator fun minus(b: Long): Long = v.toLong() - b
+	infix inline operator fun minus(b: U8): U32 = U32(v - b.v)
+	infix inline operator fun minus(b: U16): U32 = U32(v - b.v)
+	infix inline operator fun minus(b: U32): U32 = U32(v - b.v)
+	infix inline operator fun minus(b: U64): U64 = U64(v.toULong() - b.v)
+	infix inline operator fun minus(b: BigInt): BigInt = v.toBigInteger() - b
+	infix inline operator fun minus(b: Float): Float = v.toFloat() - b
+	infix inline operator fun minus(b: Double): Double = v.toDouble() - b
+	infix inline operator fun minus(b: UByte): U32 = U32(v - b)
+	infix inline operator fun minus(b: UShort): U32 = U32(v - b)
+	infix inline operator fun minus(b: UInt): U32 = U32(v - b)
+	infix inline operator fun minus(b: ULong): ULong = v.toULong() - b
+	infix inline operator fun times(b: Byte): U32 = U32(v * b.toUByte().toUInt())
+	infix inline operator fun times(b: Short): U32 = U32(v * b.toUShort().toUInt())
+	infix inline operator fun times(b: Int): U32 = U32(v * b.toUInt())
+	infix inline operator fun times(b: Long): Long = v.toLong() * b
+	infix inline operator fun times(b: U8): U32 = U32(v * b.v)
+	infix inline operator fun times(b: U16): U32 = U32(v * b.v)
+	infix inline operator fun times(b: U32): U32 = U32(v * b.v)
+	infix inline operator fun times(b: U64): U64 = U64(v.toULong() * b.v)
+	infix inline operator fun times(b: BigInt): BigInt = v.toBigInteger() * b
+	infix inline operator fun times(b: Float): Float = v.toFloat() * b
+	infix inline operator fun times(b: Double): Double = v.toDouble() * b
+	infix inline operator fun times(b: UByte): U32 = U32(v * b)
+	infix inline operator fun times(b: UShort): U32 = U32(v * b)
+	infix inline operator fun times(b: UInt): U32 = U32(v * b)
+	infix inline operator fun times(b: ULong): ULong = v.toULong() * b
+	infix inline operator fun div(b: Byte): U32 = U32(v / b.toUByte().toUInt())
+	infix inline operator fun div(b: Short): U32 = U32(v / b.toUShort().toUInt())
+	infix inline operator fun div(b: Int): U32 = U32(v / b.toUInt())
+	infix inline operator fun div(b: Long): Long = v.toLong() / b
+	infix inline operator fun div(b: U8): U32 = U32(v / b.v)
+	infix inline operator fun div(b: U16): U32 = U32(v / b.v)
+	infix inline operator fun div(b: U32): U32 = U32(v / b.v)
+	infix inline operator fun div(b: U64): U64 = U64(v.toULong() / b.v)
+	infix inline operator fun div(b: BigInt): BigInt = v.toBigInteger() / b
+	infix inline operator fun div(b: Float): Float = v.toFloat() / b
+	infix inline operator fun div(b: Double): Double = v.toDouble() / b
+	infix inline operator fun div(b: UByte): U32 = U32(v / b)
+	infix inline operator fun div(b: UShort): U32 = U32(v / b)
+	infix inline operator fun div(b: UInt): U32 = U32(v / b)
+	infix inline operator fun div(b: ULong): ULong = v.toULong() / b
+	infix inline operator fun rem(b: Byte): U32 = U32(v % b.toUByte().toUInt())
+	infix inline operator fun rem(b: Short): U32 = U32(v % b.toUShort().toUInt())
+	infix inline operator fun rem(b: Int): U32 = U32(v % b.toUInt())
+	infix inline operator fun rem(b: Long): Long = v.toLong() % b
+	infix inline operator fun rem(b: U8): U32 = U32(v % b.v)
+	infix inline operator fun rem(b: U16): U32 = U32(v % b.v)
+	infix inline operator fun rem(b: U32): U32 = U32(v % b.v)
+	infix inline operator fun rem(b: U64): U64 = U64(v.toULong() % b.v)
+	infix inline operator fun rem(b: BigInt): BigInt = v.toBigInteger() % b
+	infix inline operator fun rem(b: Float): Float = v.toFloat() % b
+	infix inline operator fun rem(b: Double): Double = v.toDouble() % b
+	infix inline operator fun rem(b: UByte): U32 = U32(v % b)
+	infix inline operator fun rem(b: UShort): U32 = U32(v % b)
+	infix inline operator fun rem(b: UInt): U32 = U32(v % b)
+	infix inline operator fun rem(b: ULong): ULong = v.toULong() % b
+	inline operator fun plusAssign(b: Byte) { v += b.toUByte().toUInt() }
+	inline operator fun plusAssign(b: Short) { v += b.toUShort().toUInt() }
+	inline operator fun plusAssign(b: Int) { v += b.toUInt() }
+	inline operator fun plusAssign(b: Long) { v = (v.toLong() + b).toUInt() }
+	inline operator fun plusAssign(b: U8) { v += b.v }
+	inline operator fun plusAssign(b: U16) { v += b.v }
+	inline operator fun plusAssign(b: U32) { v += b.v }
+	inline operator fun plusAssign(b: U64) { v = (v.toULong() + b.v).toUInt() }
+	inline operator fun plusAssign(b: BigInt) { v = (v.toBigInteger() + b).uintValue() }
+	inline operator fun plusAssign(b: Float) { v = (v.toFloat() + b).toUInt() }
+	inline operator fun plusAssign(b: Double) { v = (v.toDouble() + b).toUInt() }
+	inline operator fun plusAssign(b: UByte) { v += b }
+	inline operator fun plusAssign(b: UShort) { v += b }
+	inline operator fun plusAssign(b: UInt) { v += b }
+	inline operator fun plusAssign(b: ULong) { v = (v.toULong() + b).toUInt() }
+	inline operator fun minusAssign(b: Byte) { v -= b.toUByte().toUInt() }
+	inline operator fun minusAssign(b: Short) { v -= b.toUShort().toUInt() }
+	inline operator fun minusAssign(b: Int) { v -= b.toUInt() }
+	inline operator fun minusAssign(b: Long) { v = (v.toLong() - b).toUInt() }
+	inline operator fun minusAssign(b: U8) { v -= b.v }
+	inline operator fun minusAssign(b: U16) { v -= b.v }
+	inline operator fun minusAssign(b: U32) { v -= b.v }
+	inline operator fun minusAssign(b: U64) { v = (v.toULong() - b.v).toUInt() }
+	inline operator fun minusAssign(b: BigInt) { v = (v.toBigInteger() - b).uintValue() }
+	inline operator fun minusAssign(b: Float) { v = (v.toFloat() - b).toUInt() }
+	inline operator fun minusAssign(b: Double) { v = (v.toDouble() - b).toUInt() }
+	inline operator fun minusAssign(b: UByte) { v -= b }
+	inline operator fun minusAssign(b: UShort) { v -= b }
+	inline operator fun minusAssign(b: UInt) { v -= b }
+	inline operator fun minusAssign(b: ULong) { v = (v.toULong() - b).toUInt() }
+	inline operator fun timesAssign(b: Byte) { v *= b.toUByte().toUInt() }
+	inline operator fun timesAssign(b: Short) { v *= b.toUShort().toUInt() }
+	inline operator fun timesAssign(b: Int) { v *= b.toUInt() }
+	inline operator fun timesAssign(b: Long) { v = (v.toLong() * b).toUInt() }
+	inline operator fun timesAssign(b: U8) { v *= b.v }
+	inline operator fun timesAssign(b: U16) { v *= b.v }
+	inline operator fun timesAssign(b: U32) { v *= b.v }
+	inline operator fun timesAssign(b: U64) { v = (v.toULong() * b.v).toUInt() }
+	inline operator fun timesAssign(b: BigInt) { v = (v.toBigInteger() * b).uintValue() }
+	inline operator fun timesAssign(b: Float) { v = (v.toFloat() * b).toUInt() }
+	inline operator fun timesAssign(b: Double) { v = (v.toDouble() * b).toUInt() }
+	inline operator fun timesAssign(b: UByte) { v *= b }
+	inline operator fun timesAssign(b: UShort) { v *= b }
+	inline operator fun timesAssign(b: UInt) { v *= b }
+	inline operator fun timesAssign(b: ULong) { v = (v.toULong() * b).toUInt() }
+	inline operator fun divAssign(b: Byte) { v /= b.toUByte().toUInt() }
+	inline operator fun divAssign(b: Short) { v /= b.toUShort().toUInt() }
+	inline operator fun divAssign(b: Int) { v /= b.toUInt() }
+	inline operator fun divAssign(b: Long) { v = (v.toLong() / b).toUInt() }
+	inline operator fun divAssign(b: U8) { v /= b.v }
+	inline operator fun divAssign(b: U16) { v /= b.v }
+	inline operator fun divAssign(b: U32) { v /= b.v }
+	inline operator fun divAssign(b: U64) { v = (v.toULong() / b.v).toUInt() }
+	inline operator fun divAssign(b: BigInt) { v = (v.toBigInteger() / b).uintValue() }
+	inline operator fun divAssign(b: Float) { v = (v.toFloat() / b).toUInt() }
+	inline operator fun divAssign(b: Double) { v = (v.toDouble() / b).toUInt() }
+	inline operator fun divAssign(b: UByte) { v /= b }
+	inline operator fun divAssign(b: UShort) { v /= b }
+	inline operator fun divAssign(b: UInt) { v /= b }
+	inline operator fun divAssign(b: ULong) { v = (v.toULong() / b).toUInt() }
+	inline operator fun remAssign(b: Byte) { v %= b.toUByte().toUInt() }
+	inline operator fun remAssign(b: Short) { v %= b.toUShort().toUInt() }
+	inline operator fun remAssign(b: Int) { v %= b.toUInt() }
+	inline operator fun remAssign(b: Long) { v = (v.toLong() % b).toUInt() }
+	inline operator fun remAssign(b: U8) { v %= b.v }
+	inline operator fun remAssign(b: U16) { v %= b.v }
+	inline operator fun remAssign(b: U32) { v %= b.v }
+	inline operator fun remAssign(b: U64) { v = (v.toULong() % b.v).toUInt() }
+	inline operator fun remAssign(b: BigInt) { v = (v.toBigInteger() % b).uintValue() }
+	inline operator fun remAssign(b: Float) { v = (v.toFloat() % b).toUInt() }
+	inline operator fun remAssign(b: Double) { v = (v.toDouble() % b).toUInt() }
+	inline operator fun remAssign(b: UByte) { v %= b }
+	inline operator fun remAssign(b: UShort) { v %= b }
+	inline operator fun remAssign(b: UInt) { v %= b }
+	inline operator fun remAssign(b: ULong) { v = (v.toULong() % b).toUInt() }
+	inline infix fun and(b: Byte): U32 = U32(v and b.toUByte().toUInt())
+	inline infix fun and(b: Short): U32 = U32(v and b.toUShort().toUInt())
+	inline infix fun and(b: Int): U32 = U32(v and b.toUInt())
+	inline infix fun and(b: Long): U32 = U32(v and b.toULong().toUInt())
+	inline infix fun and(b: U8): U32 = U32(v and b.v.toUInt())
+	inline infix fun and(b: U16): U32 = U32(v and b.v.toUInt())
+	inline infix fun and(b: U32): U32 = U32(v and b.v)
+	inline infix fun and(b: U64): U32 = U32(v and b.v.toUInt())
+	inline infix fun and(b: BigInt): U32 = U32(v and b.uintValue())
+	inline infix fun and(b: UByte): U32 = U32(v and b.toUInt())
+	inline infix fun and(b: UShort): U32 = U32(v and b.toUInt())
+	inline infix fun and(b: UInt): U32 = U32(v and b)
+	inline infix fun and(b: ULong): U32 = U32(v and b.toUInt())
+	inline infix fun or(b: Byte): U32 = U32(v or b.toUByte().toUInt())
+	inline infix fun or(b: Short): U32 = U32(v or b.toUShort().toUInt())
+	inline infix fun or(b: Int): U32 = U32(v or b.toUInt())
+	inline infix fun or(b: Long): U32 = U32(v or b.toULong().toUInt())
+	inline infix fun or(b: U8): U32 = U32(v or b.v.toUInt())
+	inline infix fun or(b: U16): U32 = U32(v or b.v.toUInt())
+	inline infix fun or(b: U32): U32 = U32(v or b.v)
+	inline infix fun or(b: U64): U32 = U32(v or b.v.toUInt())
+	inline infix fun or(b: BigInt): U32 = U32(v or b.uintValue())
+	inline infix fun or(b: UByte): U32 = U32(v or b.toUInt())
+	inline infix fun or(b: UShort): U32 = U32(v or b.toUInt())
+	inline infix fun or(b: UInt): U32 = U32(v or b)
+	inline infix fun or(b: ULong): U32 = U32(v or b.toUInt())
+	inline infix fun xor(b: Byte): U32 = U32(v xor b.toUByte().toUInt())
+	inline infix fun xor(b: Short): U32 = U32(v xor b.toUShort().toUInt())
+	inline infix fun xor(b: Int): U32 = U32(v xor b.toUInt())
+	inline infix fun xor(b: Long): U32 = U32(v xor b.toULong().toUInt())
+	inline infix fun xor(b: U8): U32 = U32(v xor b.v.toUInt())
+	inline infix fun xor(b: U16): U32 = U32(v xor b.v.toUInt())
+	inline infix fun xor(b: U32): U32 = U32(v xor b.v)
+	inline infix fun xor(b: U64): U32 = U32(v xor b.v.toUInt())
+	inline infix fun xor(b: BigInt): U32 = U32(v xor b.uintValue())
+	inline infix fun xor(b: UByte): U32 = U32(v xor b.toUInt())
+	inline infix fun xor(b: UShort): U32 = U32(v xor b.toUInt())
+	inline infix fun xor(b: UInt): U32 = U32(v xor b)
+	inline infix fun xor(b: ULong): U32 = U32(v xor b.toUInt())
+	inline infix fun shl(b: Byte): U32 = U32(v shl b.toInt())
+	inline infix fun shl(b: Short): U32 = U32(v shl b.toInt())
+	inline infix fun shl(b: Int): U32 = U32(v shl b)
+	inline infix fun shl(b: Long): U32 = U32(v shl b.toInt())
+	inline infix fun shl(b: U8): U32 = U32(v shl b.v.toInt())
+	inline infix fun shl(b: U16): U32 = U32(v shl b.v.toInt())
+	inline infix fun shl(b: U32): U32 = U32(v shl b.v.toInt())
+	inline infix fun shl(b: U64): U32 = U32(v shl b.v.toInt())
+	inline infix fun shl(b: BigInt): U32 = U32(v shl b.intValue())
+	inline infix fun shl(b: UByte): U32 = U32(v shl b.toInt())
+	inline infix fun shl(b: UShort): U32 = U32(v shl b.toInt())
+	inline infix fun shl(b: UInt): U32 = U32(v shl b.toInt())
+	inline infix fun shl(b: ULong): U32 = U32(v shl b.toInt())
+	inline infix fun shr(b: Byte): U32 = U32(v shr b.toInt())
+	inline infix fun shr(b: Short): U32 = U32(v shr b.toInt())
+	inline infix fun shr(b: Int): U32 = U32(v shr b)
+	inline infix fun shr(b: Long): U32 = U32(v shr b.toInt())
+	inline infix fun shr(b: U8): U32 = U32(v shr b.v.toInt())
+	inline infix fun shr(b: U16): U32 = U32(v shr b.v.toInt())
+	inline infix fun shr(b: U32): U32 = U32(v shr b.v.toInt())
+	inline infix fun shr(b: U64): U32 = U32(v shr b.v.toInt())
+	inline infix fun shr(b: BigInt): U32 = U32(v shr b.intValue())
+	inline infix fun shr(b: UByte): U32 = U32(v shr b.toInt())
+	inline infix fun shr(b: UShort): U32 = U32(v shr b.toInt())
+	inline infix fun shr(b: UInt): U32 = U32(v shr b.toInt())
+	inline infix fun shr(b: ULong): U32 = U32(v shr b.toInt())
+	inline fun inv(): U32 = U32(v.inv())
+	inline infix fun andAssign(b: Byte) { v = v and b.toUInt() }
+	inline infix fun andAssign(b: Short) { v = v and b.toUInt() }
+	inline infix fun andAssign(b: Int) { v = v and b.toUInt() }
+	inline infix fun andAssign(b: Long) { v = v and b.toUInt() }
+	inline infix fun andAssign(b: U8) { v = v and b.v.toUInt() }
+	inline infix fun andAssign(b: U16) { v = v and b.v.toUInt() }
+	inline infix fun andAssign(b: U32) { v = v and b.v }
+	inline infix fun andAssign(b: U64) { v = v and b.v.toUInt() }
+	inline infix fun andAssign(b: BigInt) { v = v and b.uintValue() }
+	inline infix fun andAssign(b: UByte) { v = v and b.toUInt() }
+	inline infix fun andAssign(b: UShort) { v = v and b.toUInt() }
+	inline infix fun andAssign(b: UInt) { v = v and b }
+	inline infix fun andAssign(b: ULong) { v = v and b.toUInt() }
+	inline infix fun orAssign(b: Byte) { v = v or b.toUInt() }
+	inline infix fun orAssign(b: Short) { v = v or b.toUInt() }
+	inline infix fun orAssign(b: Int) { v = v or b.toUInt() }
+	inline infix fun orAssign(b: Long) { v = v or b.toUInt() }
+	inline infix fun orAssign(b: U8) { v = v or b.v.toUInt() }
+	inline infix fun orAssign(b: U16) { v = v or b.v.toUInt() }
+	inline infix fun orAssign(b: U32) { v = v or b.v }
+	inline infix fun orAssign(b: U64) { v = v or b.v.toUInt() }
+	inline infix fun orAssign(b: BigInt) { v = v or b.uintValue() }
+	inline infix fun orAssign(b: UByte) { v = v or b.toUInt() }
+	inline infix fun orAssign(b: UShort) { v = v or b.toUInt() }
+	inline infix fun orAssign(b: UInt) { v = v or b }
+	inline infix fun orAssign(b: ULong) { v = v or b.toUInt() }
+	inline infix fun xorAssign(b: Byte) { v = v xor b.toUInt() }
+	inline infix fun xorAssign(b: Short) { v = v xor b.toUInt() }
+	inline infix fun xorAssign(b: Int) { v = v xor b.toUInt() }
+	inline infix fun xorAssign(b: Long) { v = v xor b.toUInt() }
+	inline infix fun xorAssign(b: U8) { v = v xor b.v.toUInt() }
+	inline infix fun xorAssign(b: U16) { v = v xor b.v.toUInt() }
+	inline infix fun xorAssign(b: U32) { v = v xor b.v }
+	inline infix fun xorAssign(b: U64) { v = v xor b.v.toUInt() }
+	inline infix fun xorAssign(b: BigInt) { v = v xor b.uintValue() }
+	inline infix fun xorAssign(b: UByte) { v = v xor b.toUInt() }
+	inline infix fun xorAssign(b: UShort) { v = v xor b.toUInt() }
+	inline infix fun xorAssign(b: UInt) { v = v xor b }
+	inline infix fun xorAssign(b: ULong) { v = v xor b.toUInt() }
+	inline infix fun shlAssign(b: Byte) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: Short) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: Int) { v = v shl b }
+	inline infix fun shlAssign(b: Long) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: U8) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: U16) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: U32) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: U64) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: BigInt) { v = v shl b.intValue() }
+	inline infix fun shlAssign(b: UByte) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: UShort) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: UInt) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: ULong) { v = v shl b.toInt() }
+	inline infix fun shrAssign(b: Byte) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: Short) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: Int) { v = v shr b }
+	inline infix fun shrAssign(b: Long) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: U8) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: U16) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: U32) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: U64) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: BigInt) { v = v shr b.intValue() }
+	inline infix fun shrAssign(b: UByte) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: UShort) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: UInt) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: ULong) { v = v shr b.toInt() }
+	inline fun invAssign() { v = v.inv() }
+	infix inline operator fun compareTo(other: U8): Int = toUByte().compareTo(other.v)
+	infix inline operator fun compareTo(other: U16): Int = toUShort().compareTo(other.v)
+	infix override operator fun compareTo(other: U32): Int = v.compareTo(other.v)
+	infix inline operator fun compareTo(other: U64): Int = toULong().compareTo(other.v)
+	infix inline operator fun compareTo(other: UByte): Int = toUByte().compareTo(other)
+	infix inline operator fun compareTo(other: UShort): Int = toUShort().compareTo(other)
+	infix inline operator fun compareTo(other: UInt): Int = v.compareTo(other)
+	infix inline operator fun compareTo(other: ULong): Int = toULong().compareTo(other)
+	override fun equals(other: Any?): Boolean = other is U32 && v == other.v
+	override fun hashCode(): Int = v.hashCode()
+	override fun toString(): String = v.toString()
+	inline fun toString(radix: Int): String = v.toString(radix)
+	inline fun toString(format: String): String = format.format(this)
+}
diff --git a/src/genCommonMain/kotlin/uns/U64.kt b/src/genCommonMain/kotlin/uns/U64.kt
new file mode 100644
index 0000000..ae9541b
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/U64.kt
@@ -0,0 +1,364 @@
+@file:Suppress("NOTHING_TO_INLINE")
+package uns
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+import uns.U16
+import uns.format.format
+import uns.U8
+import kotlin.experimental.inv
+import kotlin.experimental.or
+import kotlin.experimental.and
+import uns.U32
+import kotlin.experimental.xor
+import uns.BigInt
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+
+inline fun U64(byte: Byte): U64 = U64(byte.toUByte())
+inline fun U64(short: Short): U64 = U64(short.toUShort())
+inline fun U64(int: Int): U64 = U64(int.toUInt())
+inline fun U64(long: Long): U64 = U64(long.toULong())
+class U64(var v: ULong = MIN.v) : Number(), Comparable<U64> {
+	companion object {
+		/** A bigint constant holding the minimum value an `unsigned long` can have, 0. */
+		val MIN_bigint: BigInt = BigInteger.ZERO
+		
+		/** A bigint constant holding the maximum value an `unsigned long` can have, 2^64-1. */
+		val MAX_bigint: BigInt = ULong.MAX_VALUE.toBigInteger()
+		
+		/** A constant holding the minimum value an `unsigned long` can have, 0.  */
+		val MIN = U64(ULong.MIN_VALUE)
+		
+		/** A constant holding the maximum value an `unsigned long` can have, 2^64-1. */
+		val MAX = U64(ULong.MAX_VALUE)
+		
+		/** The number of bytes used to represent an instance of UByte in a binary form. */
+		const val SIZE_BYTES: Int = ULong.SIZE_BYTES
+		
+		/** The number of bits used to represent an instance of UByte in a binary form. */
+		const val SIZE_BITS: Int = ULong.SIZE_BITS
+	}
+	constructor(u8: U8) : this(u8.toULong())
+	constructor(u16: U16) : this(u16.toULong())
+	constructor(u32: U32) : this(u32.toULong())
+	constructor(u64: U64) : this(u64.v)
+	constructor(bigint: BigInt, exactRequired: Boolean = true) : this(bigint.ulongValue(exactRequired))
+	constructor(ubyte: UByte) : this(ubyte.toULong())
+	constructor(ushort: UShort) : this(ushort.toULong())
+	constructor(uint: UInt) : this(uint.toULong())
+	constructor(string: String, radix: Int = 10) : this(string.filter { it != '_' && it != '\'' }.toULong(radix))
+	override fun toByte(): Byte = v.toByte()
+	override fun toShort(): Short = v.toShort()
+	override fun toInt(): Int = v.toInt()
+	override fun toLong(): Long = v.toLong()
+	inline fun toU8(): U8 = U8(v)
+	inline fun toU16(): U16 = U16(v)
+	inline fun toU32(): U32 = U32(v)
+	inline fun toU64(): U64 = U64(v)
+	inline fun toBigInt(): BigInt = v.toBigInteger()
+	override fun toFloat(): Float = v.toFloat()
+	override fun toDouble(): Double = v.toDouble()
+	inline fun toUByte(): UByte = v.toUByte()
+	inline fun toUShort(): UShort = v.toUShort()
+	inline fun toUInt(): UInt = v.toUInt()
+	inline fun toULong(): ULong = v
+	@Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+	override fun toChar() = toInt().toChar()
+	inline fun copy(): U64 = toU64()
+	inline operator fun inc(): U64 = U64(v.inc())
+	inline operator fun dec(): U64 = U64(v.dec())
+	infix inline operator fun plus(b: Byte): U64 = U64(v + b.toUByte().toULong())
+	infix inline operator fun plus(b: Short): U64 = U64(v + b.toUShort().toULong())
+	infix inline operator fun plus(b: Int): U64 = U64(v + b.toUInt().toULong())
+	infix inline operator fun plus(b: Long): U64 = U64(v + b.toULong())
+	infix inline operator fun plus(b: U8): U64 = U64(v + b.v)
+	infix inline operator fun plus(b: U16): U64 = U64(v + b.v)
+	infix inline operator fun plus(b: U32): U64 = U64(v + b.v)
+	infix inline operator fun plus(b: U64): U64 = U64(v + b.v)
+	infix inline operator fun plus(b: BigInt): BigInt = v.toBigInteger() + b
+	infix inline operator fun plus(b: Float): Float = v.toFloat() + b
+	infix inline operator fun plus(b: Double): Double = v.toDouble() + b
+	infix inline operator fun plus(b: UByte): U64 = U64(v + b)
+	infix inline operator fun plus(b: UShort): U64 = U64(v + b)
+	infix inline operator fun plus(b: UInt): U64 = U64(v + b)
+	infix inline operator fun plus(b: ULong): U64 = U64(v + b)
+	infix inline operator fun minus(b: Byte): U64 = U64(v - b.toUByte().toULong())
+	infix inline operator fun minus(b: Short): U64 = U64(v - b.toUShort().toULong())
+	infix inline operator fun minus(b: Int): U64 = U64(v - b.toUInt().toULong())
+	infix inline operator fun minus(b: Long): U64 = U64(v - b.toULong())
+	infix inline operator fun minus(b: U8): U64 = U64(v - b.v)
+	infix inline operator fun minus(b: U16): U64 = U64(v - b.v)
+	infix inline operator fun minus(b: U32): U64 = U64(v - b.v)
+	infix inline operator fun minus(b: U64): U64 = U64(v - b.v)
+	infix inline operator fun minus(b: BigInt): BigInt = v.toBigInteger() - b
+	infix inline operator fun minus(b: Float): Float = v.toFloat() - b
+	infix inline operator fun minus(b: Double): Double = v.toDouble() - b
+	infix inline operator fun minus(b: UByte): U64 = U64(v - b)
+	infix inline operator fun minus(b: UShort): U64 = U64(v - b)
+	infix inline operator fun minus(b: UInt): U64 = U64(v - b)
+	infix inline operator fun minus(b: ULong): U64 = U64(v - b)
+	infix inline operator fun times(b: Byte): U64 = U64(v * b.toUByte().toULong())
+	infix inline operator fun times(b: Short): U64 = U64(v * b.toUShort().toULong())
+	infix inline operator fun times(b: Int): U64 = U64(v * b.toUInt().toULong())
+	infix inline operator fun times(b: Long): U64 = U64(v * b.toULong())
+	infix inline operator fun times(b: U8): U64 = U64(v * b.v)
+	infix inline operator fun times(b: U16): U64 = U64(v * b.v)
+	infix inline operator fun times(b: U32): U64 = U64(v * b.v)
+	infix inline operator fun times(b: U64): U64 = U64(v * b.v)
+	infix inline operator fun times(b: BigInt): BigInt = v.toBigInteger() * b
+	infix inline operator fun times(b: Float): Float = v.toFloat() * b
+	infix inline operator fun times(b: Double): Double = v.toDouble() * b
+	infix inline operator fun times(b: UByte): U64 = U64(v * b)
+	infix inline operator fun times(b: UShort): U64 = U64(v * b)
+	infix inline operator fun times(b: UInt): U64 = U64(v * b)
+	infix inline operator fun times(b: ULong): U64 = U64(v * b)
+	infix inline operator fun div(b: Byte): U64 = U64(v / b.toUByte().toULong())
+	infix inline operator fun div(b: Short): U64 = U64(v / b.toUShort().toULong())
+	infix inline operator fun div(b: Int): U64 = U64(v / b.toUInt().toULong())
+	infix inline operator fun div(b: Long): U64 = U64(v / b.toULong())
+	infix inline operator fun div(b: U8): U64 = U64(v / b.v)
+	infix inline operator fun div(b: U16): U64 = U64(v / b.v)
+	infix inline operator fun div(b: U32): U64 = U64(v / b.v)
+	infix inline operator fun div(b: U64): U64 = U64(v / b.v)
+	infix inline operator fun div(b: BigInt): BigInt = v.toBigInteger() / b
+	infix inline operator fun div(b: Float): Float = v.toFloat() / b
+	infix inline operator fun div(b: Double): Double = v.toDouble() / b
+	infix inline operator fun div(b: UByte): U64 = U64(v / b)
+	infix inline operator fun div(b: UShort): U64 = U64(v / b)
+	infix inline operator fun div(b: UInt): U64 = U64(v / b)
+	infix inline operator fun div(b: ULong): U64 = U64(v / b)
+	infix inline operator fun rem(b: Byte): U64 = U64(v % b.toUByte().toULong())
+	infix inline operator fun rem(b: Short): U64 = U64(v % b.toUShort().toULong())
+	infix inline operator fun rem(b: Int): U64 = U64(v % b.toUInt().toULong())
+	infix inline operator fun rem(b: Long): U64 = U64(v % b.toULong())
+	infix inline operator fun rem(b: U8): U64 = U64(v % b.v)
+	infix inline operator fun rem(b: U16): U64 = U64(v % b.v)
+	infix inline operator fun rem(b: U32): U64 = U64(v % b.v)
+	infix inline operator fun rem(b: U64): U64 = U64(v % b.v)
+	infix inline operator fun rem(b: BigInt): BigInt = v.toBigInteger() % b
+	infix inline operator fun rem(b: Float): Float = v.toFloat() % b
+	infix inline operator fun rem(b: Double): Double = v.toDouble() % b
+	infix inline operator fun rem(b: UByte): U64 = U64(v % b)
+	infix inline operator fun rem(b: UShort): U64 = U64(v % b)
+	infix inline operator fun rem(b: UInt): U64 = U64(v % b)
+	infix inline operator fun rem(b: ULong): U64 = U64(v % b)
+	inline operator fun plusAssign(b: Byte) { v += b.toUByte().toULong() }
+	inline operator fun plusAssign(b: Short) { v += b.toUShort().toULong() }
+	inline operator fun plusAssign(b: Int) { v += b.toUInt().toULong() }
+	inline operator fun plusAssign(b: Long) { v += b.toULong() }
+	inline operator fun plusAssign(b: U8) { v += b.v }
+	inline operator fun plusAssign(b: U16) { v += b.v }
+	inline operator fun plusAssign(b: U32) { v += b.v }
+	inline operator fun plusAssign(b: U64) { v += b.v }
+	inline operator fun plusAssign(b: BigInt) { v = (v.toBigInteger() + b).ulongValue() }
+	inline operator fun plusAssign(b: Float) { v = (v.toFloat() + b).toLong().toULong() }
+	inline operator fun plusAssign(b: Double) { v = (v.toDouble() + b).toLong().toULong() }
+	inline operator fun plusAssign(b: UByte) { v += b }
+	inline operator fun plusAssign(b: UShort) { v += b }
+	inline operator fun plusAssign(b: UInt) { v += b }
+	inline operator fun plusAssign(b: ULong) { v += b }
+	inline operator fun minusAssign(b: Byte) { v -= b.toUByte().toULong() }
+	inline operator fun minusAssign(b: Short) { v -= b.toUShort().toULong() }
+	inline operator fun minusAssign(b: Int) { v -= b.toUInt().toULong() }
+	inline operator fun minusAssign(b: Long) { v -= b.toULong() }
+	inline operator fun minusAssign(b: U8) { v -= b.v }
+	inline operator fun minusAssign(b: U16) { v -= b.v }
+	inline operator fun minusAssign(b: U32) { v -= b.v }
+	inline operator fun minusAssign(b: U64) { v -= b.v }
+	inline operator fun minusAssign(b: BigInt) { v = (v.toBigInteger() - b).ulongValue() }
+	inline operator fun minusAssign(b: Float) { v = (v.toFloat() - b).toLong().toULong() }
+	inline operator fun minusAssign(b: Double) { v = (v.toDouble() - b).toLong().toULong() }
+	inline operator fun minusAssign(b: UByte) { v -= b }
+	inline operator fun minusAssign(b: UShort) { v -= b }
+	inline operator fun minusAssign(b: UInt) { v -= b }
+	inline operator fun minusAssign(b: ULong) { v -= b }
+	inline operator fun timesAssign(b: Byte) { v *= b.toUByte().toULong() }
+	inline operator fun timesAssign(b: Short) { v *= b.toUShort().toULong() }
+	inline operator fun timesAssign(b: Int) { v *= b.toUInt().toULong() }
+	inline operator fun timesAssign(b: Long) { v *= b.toULong() }
+	inline operator fun timesAssign(b: U8) { v *= b.v }
+	inline operator fun timesAssign(b: U16) { v *= b.v }
+	inline operator fun timesAssign(b: U32) { v *= b.v }
+	inline operator fun timesAssign(b: U64) { v *= b.v }
+	inline operator fun timesAssign(b: BigInt) { v = (v.toBigInteger() * b).ulongValue() }
+	inline operator fun timesAssign(b: Float) { v = (v.toFloat() * b).toLong().toULong() }
+	inline operator fun timesAssign(b: Double) { v = (v.toDouble() * b).toLong().toULong() }
+	inline operator fun timesAssign(b: UByte) { v *= b }
+	inline operator fun timesAssign(b: UShort) { v *= b }
+	inline operator fun timesAssign(b: UInt) { v *= b }
+	inline operator fun timesAssign(b: ULong) { v *= b }
+	inline operator fun divAssign(b: Byte) { v /= b.toUByte().toULong() }
+	inline operator fun divAssign(b: Short) { v /= b.toUShort().toULong() }
+	inline operator fun divAssign(b: Int) { v /= b.toUInt().toULong() }
+	inline operator fun divAssign(b: Long) { v /= b.toULong() }
+	inline operator fun divAssign(b: U8) { v /= b.v }
+	inline operator fun divAssign(b: U16) { v /= b.v }
+	inline operator fun divAssign(b: U32) { v /= b.v }
+	inline operator fun divAssign(b: U64) { v /= b.v }
+	inline operator fun divAssign(b: BigInt) { v = (v.toBigInteger() / b).ulongValue() }
+	inline operator fun divAssign(b: Float) { v = (v.toFloat() / b).toLong().toULong() }
+	inline operator fun divAssign(b: Double) { v = (v.toDouble() / b).toLong().toULong() }
+	inline operator fun divAssign(b: UByte) { v /= b }
+	inline operator fun divAssign(b: UShort) { v /= b }
+	inline operator fun divAssign(b: UInt) { v /= b }
+	inline operator fun divAssign(b: ULong) { v /= b }
+	inline operator fun remAssign(b: Byte) { v %= b.toUByte().toULong() }
+	inline operator fun remAssign(b: Short) { v %= b.toUShort().toULong() }
+	inline operator fun remAssign(b: Int) { v %= b.toUInt().toULong() }
+	inline operator fun remAssign(b: Long) { v %= b.toULong() }
+	inline operator fun remAssign(b: U8) { v %= b.v }
+	inline operator fun remAssign(b: U16) { v %= b.v }
+	inline operator fun remAssign(b: U32) { v %= b.v }
+	inline operator fun remAssign(b: U64) { v %= b.v }
+	inline operator fun remAssign(b: BigInt) { v = (v.toBigInteger() % b).ulongValue() }
+	inline operator fun remAssign(b: Float) { v = (v.toFloat() % b).toLong().toULong() }
+	inline operator fun remAssign(b: Double) { v = (v.toDouble() % b).toLong().toULong() }
+	inline operator fun remAssign(b: UByte) { v %= b }
+	inline operator fun remAssign(b: UShort) { v %= b }
+	inline operator fun remAssign(b: UInt) { v %= b }
+	inline operator fun remAssign(b: ULong) { v %= b }
+	inline infix fun and(b: Byte): U64 = U64(v and b.toUByte().toULong())
+	inline infix fun and(b: Short): U64 = U64(v and b.toUShort().toULong())
+	inline infix fun and(b: Int): U64 = U64(v and b.toUInt().toULong())
+	inline infix fun and(b: Long): U64 = U64(v and b.toULong())
+	inline infix fun and(b: U8): U64 = U64(v and b.v.toULong())
+	inline infix fun and(b: U16): U64 = U64(v and b.v.toULong())
+	inline infix fun and(b: U32): U64 = U64(v and b.v.toULong())
+	inline infix fun and(b: U64): U64 = U64(v and b.v)
+	inline infix fun and(b: BigInt): U64 = U64(v and b.ulongValue())
+	inline infix fun and(b: UByte): U64 = U64(v and b.toULong())
+	inline infix fun and(b: UShort): U64 = U64(v and b.toULong())
+	inline infix fun and(b: UInt): U64 = U64(v and b.toULong())
+	inline infix fun and(b: ULong): U64 = U64(v and b)
+	inline infix fun or(b: Byte): U64 = U64(v or b.toUByte().toULong())
+	inline infix fun or(b: Short): U64 = U64(v or b.toUShort().toULong())
+	inline infix fun or(b: Int): U64 = U64(v or b.toUInt().toULong())
+	inline infix fun or(b: Long): U64 = U64(v or b.toULong())
+	inline infix fun or(b: U8): U64 = U64(v or b.v.toULong())
+	inline infix fun or(b: U16): U64 = U64(v or b.v.toULong())
+	inline infix fun or(b: U32): U64 = U64(v or b.v.toULong())
+	inline infix fun or(b: U64): U64 = U64(v or b.v)
+	inline infix fun or(b: BigInt): U64 = U64(v or b.ulongValue())
+	inline infix fun or(b: UByte): U64 = U64(v or b.toULong())
+	inline infix fun or(b: UShort): U64 = U64(v or b.toULong())
+	inline infix fun or(b: UInt): U64 = U64(v or b.toULong())
+	inline infix fun or(b: ULong): U64 = U64(v or b)
+	inline infix fun xor(b: Byte): U64 = U64(v xor b.toUByte().toULong())
+	inline infix fun xor(b: Short): U64 = U64(v xor b.toUShort().toULong())
+	inline infix fun xor(b: Int): U64 = U64(v xor b.toUInt().toULong())
+	inline infix fun xor(b: Long): U64 = U64(v xor b.toULong())
+	inline infix fun xor(b: U8): U64 = U64(v xor b.v.toULong())
+	inline infix fun xor(b: U16): U64 = U64(v xor b.v.toULong())
+	inline infix fun xor(b: U32): U64 = U64(v xor b.v.toULong())
+	inline infix fun xor(b: U64): U64 = U64(v xor b.v)
+	inline infix fun xor(b: BigInt): U64 = U64(v xor b.ulongValue())
+	inline infix fun xor(b: UByte): U64 = U64(v xor b.toULong())
+	inline infix fun xor(b: UShort): U64 = U64(v xor b.toULong())
+	inline infix fun xor(b: UInt): U64 = U64(v xor b.toULong())
+	inline infix fun xor(b: ULong): U64 = U64(v xor b)
+	inline infix fun shl(b: Byte): U64 = U64(v shl b.toInt())
+	inline infix fun shl(b: Short): U64 = U64(v shl b.toInt())
+	inline infix fun shl(b: Int): U64 = U64(v shl b)
+	inline infix fun shl(b: Long): U64 = U64(v shl b.toInt())
+	inline infix fun shl(b: U8): U64 = U64(v shl b.v.toInt())
+	inline infix fun shl(b: U16): U64 = U64(v shl b.v.toInt())
+	inline infix fun shl(b: U32): U64 = U64(v shl b.v.toInt())
+	inline infix fun shl(b: U64): U64 = U64(v shl b.v.toInt())
+	inline infix fun shl(b: BigInt): U64 = U64(v shl b.intValue())
+	inline infix fun shl(b: UByte): U64 = U64(v shl b.toInt())
+	inline infix fun shl(b: UShort): U64 = U64(v shl b.toInt())
+	inline infix fun shl(b: UInt): U64 = U64(v shl b.toInt())
+	inline infix fun shl(b: ULong): U64 = U64(v shl b.toInt())
+	inline infix fun shr(b: Byte): U64 = U64(v shr b.toInt())
+	inline infix fun shr(b: Short): U64 = U64(v shr b.toInt())
+	inline infix fun shr(b: Int): U64 = U64(v shr b)
+	inline infix fun shr(b: Long): U64 = U64(v shr b.toInt())
+	inline infix fun shr(b: U8): U64 = U64(v shr b.v.toInt())
+	inline infix fun shr(b: U16): U64 = U64(v shr b.v.toInt())
+	inline infix fun shr(b: U32): U64 = U64(v shr b.v.toInt())
+	inline infix fun shr(b: U64): U64 = U64(v shr b.v.toInt())
+	inline infix fun shr(b: BigInt): U64 = U64(v shr b.intValue())
+	inline infix fun shr(b: UByte): U64 = U64(v shr b.toInt())
+	inline infix fun shr(b: UShort): U64 = U64(v shr b.toInt())
+	inline infix fun shr(b: UInt): U64 = U64(v shr b.toInt())
+	inline infix fun shr(b: ULong): U64 = U64(v shr b.toInt())
+	inline fun inv(): U64 = U64(v.inv())
+	inline infix fun andAssign(b: Byte) { v = v and b.toULong() }
+	inline infix fun andAssign(b: Short) { v = v and b.toULong() }
+	inline infix fun andAssign(b: Int) { v = v and b.toULong() }
+	inline infix fun andAssign(b: Long) { v = v and b.toULong() }
+	inline infix fun andAssign(b: U8) { v = v and b.v.toULong() }
+	inline infix fun andAssign(b: U16) { v = v and b.v.toULong() }
+	inline infix fun andAssign(b: U32) { v = v and b.v.toULong() }
+	inline infix fun andAssign(b: U64) { v = v and b.v }
+	inline infix fun andAssign(b: BigInt) { v = v and b.ulongValue() }
+	inline infix fun andAssign(b: UByte) { v = v and b.toULong() }
+	inline infix fun andAssign(b: UShort) { v = v and b.toULong() }
+	inline infix fun andAssign(b: UInt) { v = v and b.toULong() }
+	inline infix fun andAssign(b: ULong) { v = v and b }
+	inline infix fun orAssign(b: Byte) { v = v or b.toULong() }
+	inline infix fun orAssign(b: Short) { v = v or b.toULong() }
+	inline infix fun orAssign(b: Int) { v = v or b.toULong() }
+	inline infix fun orAssign(b: Long) { v = v or b.toULong() }
+	inline infix fun orAssign(b: U8) { v = v or b.v.toULong() }
+	inline infix fun orAssign(b: U16) { v = v or b.v.toULong() }
+	inline infix fun orAssign(b: U32) { v = v or b.v.toULong() }
+	inline infix fun orAssign(b: U64) { v = v or b.v }
+	inline infix fun orAssign(b: BigInt) { v = v or b.ulongValue() }
+	inline infix fun orAssign(b: UByte) { v = v or b.toULong() }
+	inline infix fun orAssign(b: UShort) { v = v or b.toULong() }
+	inline infix fun orAssign(b: UInt) { v = v or b.toULong() }
+	inline infix fun orAssign(b: ULong) { v = v or b }
+	inline infix fun xorAssign(b: Byte) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: Short) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: Int) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: Long) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: U8) { v = v xor b.v.toULong() }
+	inline infix fun xorAssign(b: U16) { v = v xor b.v.toULong() }
+	inline infix fun xorAssign(b: U32) { v = v xor b.v.toULong() }
+	inline infix fun xorAssign(b: U64) { v = v xor b.v }
+	inline infix fun xorAssign(b: BigInt) { v = v xor b.ulongValue() }
+	inline infix fun xorAssign(b: UByte) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: UShort) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: UInt) { v = v xor b.toULong() }
+	inline infix fun xorAssign(b: ULong) { v = v xor b }
+	inline infix fun shlAssign(b: Byte) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: Short) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: Int) { v = v shl b }
+	inline infix fun shlAssign(b: Long) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: U8) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: U16) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: U32) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: U64) { v = v shl b.v.toInt() }
+	inline infix fun shlAssign(b: BigInt) { v = v shl b.intValue() }
+	inline infix fun shlAssign(b: UByte) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: UShort) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: UInt) { v = v shl b.toInt() }
+	inline infix fun shlAssign(b: ULong) { v = v shl b.toInt() }
+	inline infix fun shrAssign(b: Byte) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: Short) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: Int) { v = v shr b }
+	inline infix fun shrAssign(b: Long) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: U8) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: U16) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: U32) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: U64) { v = v shr b.v.toInt() }
+	inline infix fun shrAssign(b: BigInt) { v = v shr b.intValue() }
+	inline infix fun shrAssign(b: UByte) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: UShort) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: UInt) { v = v shr b.toInt() }
+	inline infix fun shrAssign(b: ULong) { v = v shr b.toInt() }
+	inline fun invAssign() { v = v.inv() }
+	infix inline operator fun compareTo(other: U8): Int = toUByte().compareTo(other.v)
+	infix inline operator fun compareTo(other: U16): Int = toUShort().compareTo(other.v)
+	infix inline operator fun compareTo(other: U32): Int = toUInt().compareTo(other.v)
+	infix override operator fun compareTo(other: U64): Int = v.compareTo(other.v)
+	infix inline operator fun compareTo(other: UByte): Int = toUByte().compareTo(other)
+	infix inline operator fun compareTo(other: UShort): Int = toUShort().compareTo(other)
+	infix inline operator fun compareTo(other: UInt): Int = toUInt().compareTo(other)
+	infix inline operator fun compareTo(other: ULong): Int = v.compareTo(other)
+	override fun equals(other: Any?): Boolean = other is U64 && v == other.v
+	override fun hashCode(): Int = v.hashCode()
+	override fun toString(): String = v.toString()
+	inline fun toString(radix: Int): String = v.toString(radix)
+	inline fun toString(format: String): String = format.format(this)
+}
diff --git a/src/genCommonMain/kotlin/uns/U8.kt b/src/genCommonMain/kotlin/uns/U8.kt
new file mode 100644
index 0000000..4a1ed2b
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/U8.kt
@@ -0,0 +1,364 @@
+@file:Suppress("NOTHING_TO_INLINE")
+package uns
+
+import com.ionspin.kotlin.bignum.integer.BigInteger
+import uns.U16
+import uns.format.format
+import kotlin.experimental.inv
+import kotlin.experimental.or
+import kotlin.experimental.and
+import uns.U32
+import uns.U64
+import kotlin.experimental.xor
+import uns.BigInt
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+
+inline fun U8(byte: Byte): U8 = U8(byte.toUByte())
+inline fun U8(short: Short): U8 = U8(short.toUShort())
+inline fun U8(int: Int): U8 = U8(int.toUInt())
+inline fun U8(long: Long): U8 = U8(long.toULong())
+class U8(var v: UByte = MIN.v) : Number(), Comparable<U8> {
+	companion object {
+		/** A uint constant holding the minimum value an `unsigned byte` can have, 0. */
+		val MIN_uint: UInt = 0u
+		
+		/** A uint constant holding the maximum value an `unsigned byte` can have, 2^8-1. */
+		val MAX_uint: UInt = 0xFFu
+		
+		/** A constant holding the minimum value an `unsigned byte` can have, 0.  */
+		val MIN = U8(UByte.MIN_VALUE)
+		
+		/** A constant holding the maximum value an `unsigned byte` can have, 2^8-1. */
+		val MAX = U8(UByte.MAX_VALUE)
+		
+		/** The number of bytes used to represent an instance of UByte in a binary form. */
+		const val SIZE_BYTES: Int = UByte.SIZE_BYTES
+		
+		/** The number of bits used to represent an instance of UByte in a binary form. */
+		const val SIZE_BITS: Int = UByte.SIZE_BITS
+	}
+	constructor(u8: U8) : this(u8.v)
+	constructor(u16: U16) : this(u16.toUByte())
+	constructor(u32: U32) : this(u32.toUByte())
+	constructor(u64: U64) : this(u64.toUByte())
+	constructor(bigint: BigInt, exactRequired: Boolean = true) : this(bigint.ubyteValue(exactRequired))
+	constructor(ushort: UShort) : this(ushort.toUByte())
+	constructor(uint: UInt) : this(uint.toUByte())
+	constructor(ulong: ULong) : this(ulong.toUByte())
+	constructor(string: String, radix: Int = 10) : this(string.filter { it != '_' && it != '\'' }.toUByte(radix))
+	override fun toByte(): Byte = v.toByte()
+	override fun toShort(): Short = v.toShort()
+	override fun toInt(): Int = v.toInt()
+	override fun toLong(): Long = v.toLong()
+	inline fun toU8(): U8 = U8(v)
+	inline fun toU16(): U16 = U16(v)
+	inline fun toU32(): U32 = U32(v)
+	inline fun toU64(): U64 = U64(v)
+	inline fun toBigInt(): BigInt = v.toBigInteger()
+	override fun toFloat(): Float = v.toFloat()
+	override fun toDouble(): Double = v.toDouble()
+	inline fun toUByte(): UByte = v
+	inline fun toUShort(): UShort = v.toUShort()
+	inline fun toUInt(): UInt = v.toUInt()
+	inline fun toULong(): ULong = v.toULong()
+	@Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
+	override fun toChar() = toInt().toChar()
+	inline fun copy(): U8 = toU8()
+	inline operator fun inc(): U8 = U8(v.inc())
+	inline operator fun dec(): U8 = U8(v.dec())
+	infix inline operator fun plus(b: Byte): U8 = U8(v + b.toUByte())
+	infix inline operator fun plus(b: Short): Short = (v.toShort() + b).toShort()
+	infix inline operator fun plus(b: Int): Int = v.toInt() + b
+	infix inline operator fun plus(b: Long): Long = v.toLong() + b
+	infix inline operator fun plus(b: U8): U8 = U8(v + b.v)
+	infix inline operator fun plus(b: U16): U16 = U16(v.toUShort() + b.v)
+	infix inline operator fun plus(b: U32): U32 = U32(v.toUInt() + b.v)
+	infix inline operator fun plus(b: U64): U64 = U64(v.toULong() + b.v)
+	infix inline operator fun plus(b: BigInt): BigInt = v.toBigInteger() + b
+	infix inline operator fun plus(b: Float): Float = v.toFloat() + b
+	infix inline operator fun plus(b: Double): Double = v.toDouble() + b
+	infix inline operator fun plus(b: UByte): U8 = U8(v + b)
+	infix inline operator fun plus(b: UShort): UShort = (v.toUShort() + b).toUShort()
+	infix inline operator fun plus(b: UInt): UInt = v.toUInt() + b
+	infix inline operator fun plus(b: ULong): ULong = v.toULong() + b
+	infix inline operator fun minus(b: Byte): U8 = U8(v - b.toUByte())
+	infix inline operator fun minus(b: Short): Short = (v.toShort() - b).toShort()
+	infix inline operator fun minus(b: Int): Int = v.toInt() - b
+	infix inline operator fun minus(b: Long): Long = v.toLong() - b
+	infix inline operator fun minus(b: U8): U8 = U8(v - b.v)
+	infix inline operator fun minus(b: U16): U16 = U16(v.toUShort() - b.v)
+	infix inline operator fun minus(b: U32): U32 = U32(v.toUInt() - b.v)
+	infix inline operator fun minus(b: U64): U64 = U64(v.toULong() - b.v)
+	infix inline operator fun minus(b: BigInt): BigInt = v.toBigInteger() - b
+	infix inline operator fun minus(b: Float): Float = v.toFloat() - b
+	infix inline operator fun minus(b: Double): Double = v.toDouble() - b
+	infix inline operator fun minus(b: UByte): U8 = U8(v - b)
+	infix inline operator fun minus(b: UShort): UShort = (v.toUShort() - b).toUShort()
+	infix inline operator fun minus(b: UInt): UInt = v.toUInt() - b
+	infix inline operator fun minus(b: ULong): ULong = v.toULong() - b
+	infix inline operator fun times(b: Byte): U8 = U8(v * b.toUByte())
+	infix inline operator fun times(b: Short): Short = (v.toShort() * b).toShort()
+	infix inline operator fun times(b: Int): Int = v.toInt() * b
+	infix inline operator fun times(b: Long): Long = v.toLong() * b
+	infix inline operator fun times(b: U8): U8 = U8(v * b.v)
+	infix inline operator fun times(b: U16): U16 = U16(v.toUShort() * b.v)
+	infix inline operator fun times(b: U32): U32 = U32(v.toUInt() * b.v)
+	infix inline operator fun times(b: U64): U64 = U64(v.toULong() * b.v)
+	infix inline operator fun times(b: BigInt): BigInt = v.toBigInteger() * b
+	infix inline operator fun times(b: Float): Float = v.toFloat() * b
+	infix inline operator fun times(b: Double): Double = v.toDouble() * b
+	infix inline operator fun times(b: UByte): U8 = U8(v * b)
+	infix inline operator fun times(b: UShort): UShort = (v.toUShort() * b).toUShort()
+	infix inline operator fun times(b: UInt): UInt = v.toUInt() * b
+	infix inline operator fun times(b: ULong): ULong = v.toULong() * b
+	infix inline operator fun div(b: Byte): U8 = U8(v / b.toUByte())
+	infix inline operator fun div(b: Short): Short = (v.toShort() / b).toShort()
+	infix inline operator fun div(b: Int): Int = v.toInt() / b
+	infix inline operator fun div(b: Long): Long = v.toLong() / b
+	infix inline operator fun div(b: U8): U8 = U8(v / b.v)
+	infix inline operator fun div(b: U16): U16 = U16(v.toUShort() / b.v)
+	infix inline operator fun div(b: U32): U32 = U32(v.toUInt() / b.v)
+	infix inline operator fun div(b: U64): U64 = U64(v.toULong() / b.v)
+	infix inline operator fun div(b: BigInt): BigInt = v.toBigInteger() / b
+	infix inline operator fun div(b: Float): Float = v.toFloat() / b
+	infix inline operator fun div(b: Double): Double = v.toDouble() / b
+	infix inline operator fun div(b: UByte): U8 = U8(v / b)
+	infix inline operator fun div(b: UShort): UShort = (v.toUShort() / b).toUShort()
+	infix inline operator fun div(b: UInt): UInt = v.toUInt() / b
+	infix inline operator fun div(b: ULong): ULong = v.toULong() / b
+	infix inline operator fun rem(b: Byte): U8 = U8(v % b.toUByte())
+	infix inline operator fun rem(b: Short): Short = (v.toShort() % b).toShort()
+	infix inline operator fun rem(b: Int): Int = v.toInt() % b
+	infix inline operator fun rem(b: Long): Long = v.toLong() % b
+	infix inline operator fun rem(b: U8): U8 = U8(v % b.v)
+	infix inline operator fun rem(b: U16): U16 = U16(v.toUShort() % b.v)
+	infix inline operator fun rem(b: U32): U32 = U32(v.toUInt() % b.v)
+	infix inline operator fun rem(b: U64): U64 = U64(v.toULong() % b.v)
+	infix inline operator fun rem(b: BigInt): BigInt = v.toBigInteger() % b
+	infix inline operator fun rem(b: Float): Float = v.toFloat() % b
+	infix inline operator fun rem(b: Double): Double = v.toDouble() % b
+	infix inline operator fun rem(b: UByte): U8 = U8(v % b)
+	infix inline operator fun rem(b: UShort): UShort = (v.toUShort() % b).toUShort()
+	infix inline operator fun rem(b: UInt): UInt = v.toUInt() % b
+	infix inline operator fun rem(b: ULong): ULong = v.toULong() % b
+	inline operator fun plusAssign(b: Byte) { v = (v + b.toUByte()).toUByte() }
+	inline operator fun plusAssign(b: Short) { v = (v.toShort() + b).toUByte() }
+	inline operator fun plusAssign(b: Int) { v = (v.toInt() + b).toUByte() }
+	inline operator fun plusAssign(b: Long) { v = (v.toLong() + b).toUByte() }
+	inline operator fun plusAssign(b: U8) { v = (v + b.v).toUByte() }
+	inline operator fun plusAssign(b: U16) { v = (v.toUShort() + b.v).toUByte() }
+	inline operator fun plusAssign(b: U32) { v = (v.toUInt() + b.v).toUByte() }
+	inline operator fun plusAssign(b: U64) { v = (v.toULong() + b.v).toUByte() }
+	inline operator fun plusAssign(b: BigInt) { v = (v.toBigInteger() + b).ubyteValue() }
+	inline operator fun plusAssign(b: Float) { v = (v.toFloat() + b).toInt().toUByte() }
+	inline operator fun plusAssign(b: Double) { v = (v.toDouble() + b).toInt().toUByte() }
+	inline operator fun plusAssign(b: UByte) { v = (v + b).toUByte() }
+	inline operator fun plusAssign(b: UShort) { v = (v.toUShort() + b).toUByte() }
+	inline operator fun plusAssign(b: UInt) { v = (v.toUInt() + b).toUByte() }
+	inline operator fun plusAssign(b: ULong) { v = (v.toULong() + b).toUByte() }
+	inline operator fun minusAssign(b: Byte) { v = (v - b.toUByte()).toUByte() }
+	inline operator fun minusAssign(b: Short) { v = (v.toShort() - b).toUByte() }
+	inline operator fun minusAssign(b: Int) { v = (v.toInt() - b).toUByte() }
+	inline operator fun minusAssign(b: Long) { v = (v.toLong() - b).toUByte() }
+	inline operator fun minusAssign(b: U8) { v = (v - b.v).toUByte() }
+	inline operator fun minusAssign(b: U16) { v = (v.toUShort() - b.v).toUByte() }
+	inline operator fun minusAssign(b: U32) { v = (v.toUInt() - b.v).toUByte() }
+	inline operator fun minusAssign(b: U64) { v = (v.toULong() - b.v).toUByte() }
+	inline operator fun minusAssign(b: BigInt) { v = (v.toBigInteger() - b).ubyteValue() }
+	inline operator fun minusAssign(b: Float) { v = (v.toFloat() - b).toInt().toUByte() }
+	inline operator fun minusAssign(b: Double) { v = (v.toDouble() - b).toInt().toUByte() }
+	inline operator fun minusAssign(b: UByte) { v = (v - b).toUByte() }
+	inline operator fun minusAssign(b: UShort) { v = (v.toUShort() - b).toUByte() }
+	inline operator fun minusAssign(b: UInt) { v = (v.toUInt() - b).toUByte() }
+	inline operator fun minusAssign(b: ULong) { v = (v.toULong() - b).toUByte() }
+	inline operator fun timesAssign(b: Byte) { v = (v * b.toUByte()).toUByte() }
+	inline operator fun timesAssign(b: Short) { v = (v.toShort() * b).toUByte() }
+	inline operator fun timesAssign(b: Int) { v = (v.toInt() * b).toUByte() }
+	inline operator fun timesAssign(b: Long) { v = (v.toLong() * b).toUByte() }
+	inline operator fun timesAssign(b: U8) { v = (v * b.v).toUByte() }
+	inline operator fun timesAssign(b: U16) { v = (v.toUShort() * b.v).toUByte() }
+	inline operator fun timesAssign(b: U32) { v = (v.toUInt() * b.v).toUByte() }
+	inline operator fun timesAssign(b: U64) { v = (v.toULong() * b.v).toUByte() }
+	inline operator fun timesAssign(b: BigInt) { v = (v.toBigInteger() * b).ubyteValue() }
+	inline operator fun timesAssign(b: Float) { v = (v.toFloat() * b).toInt().toUByte() }
+	inline operator fun timesAssign(b: Double) { v = (v.toDouble() * b).toInt().toUByte() }
+	inline operator fun timesAssign(b: UByte) { v = (v * b).toUByte() }
+	inline operator fun timesAssign(b: UShort) { v = (v.toUShort() * b).toUByte() }
+	inline operator fun timesAssign(b: UInt) { v = (v.toUInt() * b).toUByte() }
+	inline operator fun timesAssign(b: ULong) { v = (v.toULong() * b).toUByte() }
+	inline operator fun divAssign(b: Byte) { v = (v / b.toUByte()).toUByte() }
+	inline operator fun divAssign(b: Short) { v = (v.toShort() / b).toUByte() }
+	inline operator fun divAssign(b: Int) { v = (v.toInt() / b).toUByte() }
+	inline operator fun divAssign(b: Long) { v = (v.toLong() / b).toUByte() }
+	inline operator fun divAssign(b: U8) { v = (v / b.v).toUByte() }
+	inline operator fun divAssign(b: U16) { v = (v.toUShort() / b.v).toUByte() }
+	inline operator fun divAssign(b: U32) { v = (v.toUInt() / b.v).toUByte() }
+	inline operator fun divAssign(b: U64) { v = (v.toULong() / b.v).toUByte() }
+	inline operator fun divAssign(b: BigInt) { v = (v.toBigInteger() / b).ubyteValue() }
+	inline operator fun divAssign(b: Float) { v = (v.toFloat() / b).toInt().toUByte() }
+	inline operator fun divAssign(b: Double) { v = (v.toDouble() / b).toInt().toUByte() }
+	inline operator fun divAssign(b: UByte) { v = (v / b).toUByte() }
+	inline operator fun divAssign(b: UShort) { v = (v.toUShort() / b).toUByte() }
+	inline operator fun divAssign(b: UInt) { v = (v.toUInt() / b).toUByte() }
+	inline operator fun divAssign(b: ULong) { v = (v.toULong() / b).toUByte() }
+	inline operator fun remAssign(b: Byte) { v = (v % b.toUByte()).toUByte() }
+	inline operator fun remAssign(b: Short) { v = (v.toShort() % b).toUByte() }
+	inline operator fun remAssign(b: Int) { v = (v.toInt() % b).toUByte() }
+	inline operator fun remAssign(b: Long) { v = (v.toLong() % b).toUByte() }
+	inline operator fun remAssign(b: U8) { v = (v % b.v).toUByte() }
+	inline operator fun remAssign(b: U16) { v = (v.toUShort() % b.v).toUByte() }
+	inline operator fun remAssign(b: U32) { v = (v.toUInt() % b.v).toUByte() }
+	inline operator fun remAssign(b: U64) { v = (v.toULong() % b.v).toUByte() }
+	inline operator fun remAssign(b: BigInt) { v = (v.toBigInteger() % b).ubyteValue() }
+	inline operator fun remAssign(b: Float) { v = (v.toFloat() % b).toInt().toUByte() }
+	inline operator fun remAssign(b: Double) { v = (v.toDouble() % b).toInt().toUByte() }
+	inline operator fun remAssign(b: UByte) { v = (v % b).toUByte() }
+	inline operator fun remAssign(b: UShort) { v = (v.toUShort() % b).toUByte() }
+	inline operator fun remAssign(b: UInt) { v = (v.toUInt() % b).toUByte() }
+	inline operator fun remAssign(b: ULong) { v = (v.toULong() % b).toUByte() }
+	inline infix fun and(b: Byte): U8 = U8(v and b.toUByte())
+	inline infix fun and(b: Short): U8 = U8(v and b.toUShort().toUByte())
+	inline infix fun and(b: Int): U8 = U8(v and b.toUInt().toUByte())
+	inline infix fun and(b: Long): U8 = U8(v and b.toULong().toUByte())
+	inline infix fun and(b: U8): U8 = U8(v and b.v)
+	inline infix fun and(b: U16): U8 = U8(v and b.v.toUByte())
+	inline infix fun and(b: U32): U8 = U8(v and b.v.toUByte())
+	inline infix fun and(b: U64): U8 = U8(v and b.v.toUByte())
+	inline infix fun and(b: BigInt): U8 = U8(v and b.ubyteValue())
+	inline infix fun and(b: UByte): U8 = U8(v and b)
+	inline infix fun and(b: UShort): U8 = U8(v and b.toUByte())
+	inline infix fun and(b: UInt): U8 = U8(v and b.toUByte())
+	inline infix fun and(b: ULong): U8 = U8(v and b.toUByte())
+	inline infix fun or(b: Byte): U8 = U8(v or b.toUByte())
+	inline infix fun or(b: Short): U8 = U8(v or b.toUShort().toUByte())
+	inline infix fun or(b: Int): U8 = U8(v or b.toUInt().toUByte())
+	inline infix fun or(b: Long): U8 = U8(v or b.toULong().toUByte())
+	inline infix fun or(b: U8): U8 = U8(v or b.v)
+	inline infix fun or(b: U16): U8 = U8(v or b.v.toUByte())
+	inline infix fun or(b: U32): U8 = U8(v or b.v.toUByte())
+	inline infix fun or(b: U64): U8 = U8(v or b.v.toUByte())
+	inline infix fun or(b: BigInt): U8 = U8(v or b.ubyteValue())
+	inline infix fun or(b: UByte): U8 = U8(v or b)
+	inline infix fun or(b: UShort): U8 = U8(v or b.toUByte())
+	inline infix fun or(b: UInt): U8 = U8(v or b.toUByte())
+	inline infix fun or(b: ULong): U8 = U8(v or b.toUByte())
+	inline infix fun xor(b: Byte): U8 = U8(v xor b.toUByte())
+	inline infix fun xor(b: Short): U8 = U8(v xor b.toUShort().toUByte())
+	inline infix fun xor(b: Int): U8 = U8(v xor b.toUInt().toUByte())
+	inline infix fun xor(b: Long): U8 = U8(v xor b.toULong().toUByte())
+	inline infix fun xor(b: U8): U8 = U8(v xor b.v)
+	inline infix fun xor(b: U16): U8 = U8(v xor b.v.toUByte())
+	inline infix fun xor(b: U32): U8 = U8(v xor b.v.toUByte())
+	inline infix fun xor(b: U64): U8 = U8(v xor b.v.toUByte())
+	inline infix fun xor(b: BigInt): U8 = U8(v xor b.ubyteValue())
+	inline infix fun xor(b: UByte): U8 = U8(v xor b)
+	inline infix fun xor(b: UShort): U8 = U8(v xor b.toUByte())
+	inline infix fun xor(b: UInt): U8 = U8(v xor b.toUByte())
+	inline infix fun xor(b: ULong): U8 = U8(v xor b.toUByte())
+	inline infix fun shl(b: Byte): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: Short): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: Int): U8 = U8(v.toUInt() shl b)
+	inline infix fun shl(b: Long): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: U8): U8 = U8(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: U16): U8 = U8(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: U32): U8 = U8(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: U64): U8 = U8(v.toUInt() shl b.v.toInt())
+	inline infix fun shl(b: BigInt): U8 = U8(v.toUInt() shl b.intValue())
+	inline infix fun shl(b: UByte): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: UShort): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: UInt): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shl(b: ULong): U8 = U8(v.toUInt() shl b.toInt())
+	inline infix fun shr(b: Byte): U8 = U8(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: Short): U8 = U8(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: Int): U8 = U8(v.toUInt() shr b)
+	inline infix fun shr(b: Long): U8 = U8(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: U8): U8 = U8(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: U16): U8 = U8(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: U32): U8 = U8(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: U64): U8 = U8(v.toUInt() shr b.v.toInt())
+	inline infix fun shr(b: BigInt): U8 = U8(v.toUInt() shr b.intValue())
+	inline infix fun shr(b: UByte): U8 = U8(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: UShort): U8 = U8(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: UInt): U8 = U8(v.toUInt() shr b.toInt())
+	inline infix fun shr(b: ULong): U8 = U8(v.toUInt() shr b.toInt())
+	inline fun inv(): U8 = U8(v.inv())
+	inline infix fun andAssign(b: Byte) { v = v and b.toUByte() }
+	inline infix fun andAssign(b: Short) { v = v and b.toUByte() }
+	inline infix fun andAssign(b: Int) { v = v and b.toUByte() }
+	inline infix fun andAssign(b: Long) { v = v and b.toUByte() }
+	inline infix fun andAssign(b: U8) { v = v and b.v }
+	inline infix fun andAssign(b: U16) { v = v and b.v.toUByte() }
+	inline infix fun andAssign(b: U32) { v = v and b.v.toUByte() }
+	inline infix fun andAssign(b: U64) { v = v and b.v.toUByte() }
+	inline infix fun andAssign(b: BigInt) { v = v and b.ubyteValue() }
+	inline infix fun andAssign(b: UByte) { v = v and b }
+	inline infix fun andAssign(b: UShort) { v = v and b.toUByte() }
+	inline infix fun andAssign(b: UInt) { v = v and b.toUByte() }
+	inline infix fun andAssign(b: ULong) { v = v and b.toUByte() }
+	inline infix fun orAssign(b: Byte) { v = v or b.toUByte() }
+	inline infix fun orAssign(b: Short) { v = v or b.toUByte() }
+	inline infix fun orAssign(b: Int) { v = v or b.toUByte() }
+	inline infix fun orAssign(b: Long) { v = v or b.toUByte() }
+	inline infix fun orAssign(b: U8) { v = v or b.v }
+	inline infix fun orAssign(b: U16) { v = v or b.v.toUByte() }
+	inline infix fun orAssign(b: U32) { v = v or b.v.toUByte() }
+	inline infix fun orAssign(b: U64) { v = v or b.v.toUByte() }
+	inline infix fun orAssign(b: BigInt) { v = v or b.ubyteValue() }
+	inline infix fun orAssign(b: UByte) { v = v or b }
+	inline infix fun orAssign(b: UShort) { v = v or b.toUByte() }
+	inline infix fun orAssign(b: UInt) { v = v or b.toUByte() }
+	inline infix fun orAssign(b: ULong) { v = v or b.toUByte() }
+	inline infix fun xorAssign(b: Byte) { v = v xor b.toUByte() }
+	inline infix fun xorAssign(b: Short) { v = v xor b.toUByte() }
+	inline infix fun xorAssign(b: Int) { v = v xor b.toUByte() }
+	inline infix fun xorAssign(b: Long) { v = v xor b.toUByte() }
+	inline infix fun xorAssign(b: U8) { v = v xor b.v }
+	inline infix fun xorAssign(b: U16) { v = v xor b.v.toUByte() }
+	inline infix fun xorAssign(b: U32) { v = v xor b.v.toUByte() }
+	inline infix fun xorAssign(b: U64) { v = v xor b.v.toUByte() }
+	inline infix fun xorAssign(b: BigInt) { v = v xor b.ubyteValue() }
+	inline infix fun xorAssign(b: UByte) { v = v xor b }
+	inline infix fun xorAssign(b: UShort) { v = v xor b.toUByte() }
+	inline infix fun xorAssign(b: UInt) { v = v xor b.toUByte() }
+	inline infix fun xorAssign(b: ULong) { v = v xor b.toUByte() }
+	inline infix fun shlAssign(b: Byte) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: Short) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: Int) { v = (v.toUInt() shl b).toUByte() }
+	inline infix fun shlAssign(b: Long) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: U8) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: U16) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: U32) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: U64) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: BigInt) { v = (v.toUInt() shl b.intValue()).toUByte() }
+	inline infix fun shlAssign(b: UByte) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: UShort) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: UInt) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shlAssign(b: ULong) { v = (v.toUInt() shl b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: Byte) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: Short) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: Int) { v = (v.toUInt() shr b).toUByte() }
+	inline infix fun shrAssign(b: Long) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: U8) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: U16) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: U32) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: U64) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: BigInt) { v = (v.toUInt() shr b.intValue()).toUByte() }
+	inline infix fun shrAssign(b: UByte) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: UShort) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: UInt) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline infix fun shrAssign(b: ULong) { v = (v.toUInt() shr b.toInt()).toUByte() }
+	inline fun invAssign() { v = v.inv() }
+	infix override operator fun compareTo(other: U8): Int = v.compareTo(other.v)
+	infix inline operator fun compareTo(other: U16): Int = toUShort().compareTo(other.v)
+	infix inline operator fun compareTo(other: U32): Int = toUInt().compareTo(other.v)
+	infix inline operator fun compareTo(other: U64): Int = toULong().compareTo(other.v)
+	infix inline operator fun compareTo(other: UByte): Int = v.compareTo(other)
+	infix inline operator fun compareTo(other: UShort): Int = toUShort().compareTo(other)
+	infix inline operator fun compareTo(other: UInt): Int = toUInt().compareTo(other)
+	infix inline operator fun compareTo(other: ULong): Int = toULong().compareTo(other)
+	override fun equals(other: Any?): Boolean = other is U8 && v == other.v
+	override fun hashCode(): Int = v.hashCode()
+	override fun toString(): String = v.toString()
+	inline fun toString(radix: Int): String = v.toString(radix)
+	inline fun toString(format: String): String = format.format(this)
+}
diff --git a/src/genCommonMain/kotlin/uns/arrays.kt b/src/genCommonMain/kotlin/uns/arrays.kt
new file mode 100644
index 0000000..fd5962f
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/arrays.kt
@@ -0,0 +1,147 @@
+@file:OptIn(kotlin.experimental.ExperimentalTypeInference::class, kotlin.ExperimentalUnsignedTypes::class)
+package uns
+
+import kotlin.jvm.JvmName
+import kotlin.experimental.ExperimentalTypeInference
+import kotlin.jvm.JvmInline
+
+@JvmInline
+value class U8Array(val data: UByteArray) {
+
+    operator fun get(index: I32): U8 = U8(data[index])
+
+    operator fun set(index: I32, value: U8) { data[index] = value.v }
+    
+    val indices: IntRange
+        get() = data.indices
+}
+
+fun U8Array(size: I32): U8Array = U8Array(UByteArray(size))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U8ArrayUByte")
+inline fun U8Array(size: I32, init: (I32) -> UByte): U8Array = U8Array(UByteArray(size, init))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U8ArrayU8")
+inline fun U8Array(size: I32, init: (I32) -> U8): U8Array {
+    val array = U8Array(UByteArray(size))
+    for (i in array.indices)
+        array[i] = init(i)
+    return array
+}
+@OverloadResolutionByLambdaReturnType
+@JvmName("U8ArrayI32")
+inline fun U8Array(size: I32, init: (I32) -> I32): U8Array {
+    val array = U8Array(UByteArray(size))
+    for (i in array.indices)
+        array.data[i] = init(i).toUByte()
+    return array
+}
+@OverloadResolutionByLambdaReturnType
+@JvmName("U8ArrayU32")
+inline fun U8Array(size: I32, init: (I32) -> U32): U8Array {
+    val array = U8Array(UByteArray(size))
+    for (i in array.indices)
+        array.data[i] = init(i).toUByte()
+    return array
+}
+@JvmInline
+value class U16Array(val data: UShortArray) {
+
+    operator fun get(index: I32): U16 = U16(data[index])
+
+    operator fun set(index: I32, value: U16) { data[index] = value.v }
+    
+    val indices: IntRange
+        get() = data.indices
+}
+
+fun U16Array(size: I32): U16Array = U16Array(UShortArray(size))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U16ArrayUShort")
+inline fun U16Array(size: I32, init: (I32) -> UShort): U16Array = U16Array(UShortArray(size, init))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U16ArrayU16")
+inline fun U16Array(size: I32, init: (I32) -> U16): U16Array {
+    val array = U16Array(UShortArray(size))
+    for (i in array.indices)
+        array[i] = init(i)
+    return array
+}
+@OverloadResolutionByLambdaReturnType
+@JvmName("U16ArrayI32")
+inline fun U16Array(size: I32, init: (I32) -> I32): U16Array {
+    val array = U16Array(UShortArray(size))
+    for (i in array.indices)
+        array.data[i] = init(i).toUShort()
+    return array
+}
+@OverloadResolutionByLambdaReturnType
+@JvmName("U16ArrayU32")
+inline fun U16Array(size: I32, init: (I32) -> U32): U16Array {
+    val array = U16Array(UShortArray(size))
+    for (i in array.indices)
+        array.data[i] = init(i).toUShort()
+    return array
+}
+@JvmInline
+value class U32Array(val data: UIntArray) {
+
+    operator fun get(index: I32): U32 = U32(data[index])
+
+    operator fun set(index: I32, value: U32) { data[index] = value.v }
+    
+    val indices: IntRange
+        get() = data.indices
+}
+
+fun U32Array(size: I32): U32Array = U32Array(UIntArray(size))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U32ArrayUInt")
+inline fun U32Array(size: I32, init: (I32) -> UInt): U32Array = U32Array(UIntArray(size, init))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U32ArrayU32")
+inline fun U32Array(size: I32, init: (I32) -> U32): U32Array {
+    val array = U32Array(UIntArray(size))
+    for (i in array.indices)
+        array[i] = init(i)
+    return array
+}
+@JvmInline
+value class U64Array(val data: ULongArray) {
+
+    operator fun get(index: I32): U64 = U64(data[index])
+
+    operator fun set(index: I32, value: U64) { data[index] = value.v }
+    
+    val indices: IntRange
+        get() = data.indices
+}
+
+fun U64Array(size: I32): U64Array = U64Array(ULongArray(size))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U64ArrayULong")
+inline fun U64Array(size: I32, init: (I32) -> ULong): U64Array = U64Array(ULongArray(size, init))
+@OverloadResolutionByLambdaReturnType
+@JvmName("U64ArrayU64")
+inline fun U64Array(size: I32, init: (I32) -> U64): U64Array {
+    val array = U64Array(ULongArray(size))
+    for (i in array.indices)
+        array[i] = init(i)
+    return array
+}
+@OverloadResolutionByLambdaReturnType
+@JvmName("U64ArrayI32")
+inline fun U64Array(size: I32, init: (I32) -> I32): U64Array {
+    val array = U64Array(ULongArray(size))
+    for (i in array.indices)
+        array.data[i] = init(i).toULong()
+    return array
+}
+@OverloadResolutionByLambdaReturnType
+@JvmName("U64ArrayU32")
+inline fun U64Array(size: I32, init: (I32) -> U32): U64Array {
+    val array = U64Array(ULongArray(size))
+    for (i in array.indices)
+        array.data[i] = init(i).toULong()
+    return array
+}
diff --git a/src/genCommonMain/kotlin/uns/extensions.kt b/src/genCommonMain/kotlin/uns/extensions.kt
new file mode 100644
index 0000000..73339d5
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/extensions.kt
@@ -0,0 +1,442 @@
+package uns
+
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+
+inline val Byte.i16: I16
+    get() = toShort()
+inline val Byte.i32: I32
+    get() = toInt()
+inline val Byte.i: I32
+    get() = i32
+inline val Byte.i64: I64
+    get() = toLong()
+inline val Byte.L: I64
+    get() = i64
+inline val Byte.u8: U8
+    get() = U8(this)
+inline val Byte.u16: U16
+    get() = U16(this)
+inline val Byte.u32: U32
+    get() = U32(this)
+inline val Byte.u64: U64
+    get() = U64(this)
+inline val Byte.bigInt: BigInt
+    get() = toBigInteger()
+inline val Byte.ub: UByte
+    get() = toUByte()
+inline val Byte.us: UShort
+    get() = toUShort()
+inline val Byte.ui: UInt
+    get() = toUInt()
+inline val Byte.ul: ULong
+    get() = toULong()
+inline val Byte.f32: F32
+    get() = toFloat()
+inline val Byte.f: F32
+    get() = f32
+inline val Byte.f64: F64
+    get() = toDouble()
+inline val Short.i8: I8
+    get() = toByte()
+inline val Short.i32: I32
+    get() = toInt()
+inline val Short.i: I32
+    get() = i32
+inline val Short.i64: I64
+    get() = toLong()
+inline val Short.L: I64
+    get() = i64
+inline val Short.u8: U8
+    get() = U8(this)
+inline val Short.u16: U16
+    get() = U16(this)
+inline val Short.u32: U32
+    get() = U32(this)
+inline val Short.u64: U64
+    get() = U64(this)
+inline val Short.bigInt: BigInt
+    get() = toBigInteger()
+inline val Short.ub: UByte
+    get() = toUByte()
+inline val Short.us: UShort
+    get() = toUShort()
+inline val Short.ui: UInt
+    get() = toUInt()
+inline val Short.ul: ULong
+    get() = toULong()
+inline val Short.f32: F32
+    get() = toFloat()
+inline val Short.f: F32
+    get() = f32
+inline val Short.f64: F64
+    get() = toDouble()
+inline val Int.i8: I8
+    get() = toByte()
+inline val Int.i16: I16
+    get() = toShort()
+inline val Int.i64: I64
+    get() = toLong()
+inline val Int.L: I64
+    get() = i64
+inline val Int.u8: U8
+    get() = U8(this)
+inline val Int.u16: U16
+    get() = U16(this)
+inline val Int.u32: U32
+    get() = U32(this)
+inline val Int.u64: U64
+    get() = U64(this)
+inline val Int.bigInt: BigInt
+    get() = toBigInteger()
+inline val Int.ub: UByte
+    get() = toUByte()
+inline val Int.us: UShort
+    get() = toUShort()
+inline val Int.ui: UInt
+    get() = toUInt()
+inline val Int.ul: ULong
+    get() = toULong()
+inline val Int.f32: F32
+    get() = toFloat()
+inline val Int.f: F32
+    get() = f32
+inline val Int.f64: F64
+    get() = toDouble()
+inline val Long.i8: I8
+    get() = toByte()
+inline val Long.i16: I16
+    get() = toShort()
+inline val Long.i32: I32
+    get() = toInt()
+inline val Long.i: I32
+    get() = i32
+inline val Long.u8: U8
+    get() = U8(this)
+inline val Long.u16: U16
+    get() = U16(this)
+inline val Long.u32: U32
+    get() = U32(this)
+inline val Long.u64: U64
+    get() = U64(this)
+inline val Long.bigInt: BigInt
+    get() = toBigInteger()
+inline val Long.ub: UByte
+    get() = toUByte()
+inline val Long.us: UShort
+    get() = toUShort()
+inline val Long.ui: UInt
+    get() = toUInt()
+inline val Long.ul: ULong
+    get() = toULong()
+inline val Long.f32: F32
+    get() = toFloat()
+inline val Long.f: F32
+    get() = f32
+inline val Long.f64: F64
+    get() = toDouble()
+inline val U8.i8: I8
+    get() = toByte()
+inline val U8.i16: I16
+    get() = toShort()
+inline val U8.i32: I32
+    get() = toInt()
+inline val U8.i: I32
+    get() = i32
+inline val U8.i64: I64
+    get() = toLong()
+inline val U8.L: I64
+    get() = i64
+inline val U8.u16: U16
+    get() = U16(this)
+inline val U8.u32: U32
+    get() = U32(this)
+inline val U8.u64: U64
+    get() = U64(this)
+inline val U8.bigInt: BigInt
+    get() = toBigInt()
+inline val U8.ub: UByte
+    get() = toUByte()
+inline val U8.us: UShort
+    get() = toUShort()
+inline val U8.ui: UInt
+    get() = toUInt()
+inline val U8.ul: ULong
+    get() = toULong()
+inline val U8.f32: F32
+    get() = toFloat()
+inline val U8.f: F32
+    get() = f32
+inline val U8.f64: F64
+    get() = toDouble()
+inline val U16.i8: I8
+    get() = toByte()
+inline val U16.i16: I16
+    get() = toShort()
+inline val U16.i32: I32
+    get() = toInt()
+inline val U16.i: I32
+    get() = i32
+inline val U16.i64: I64
+    get() = toLong()
+inline val U16.L: I64
+    get() = i64
+inline val U16.u8: U8
+    get() = U8(this)
+inline val U16.u32: U32
+    get() = U32(this)
+inline val U16.u64: U64
+    get() = U64(this)
+inline val U16.bigInt: BigInt
+    get() = toBigInt()
+inline val U16.ub: UByte
+    get() = toUByte()
+inline val U16.us: UShort
+    get() = toUShort()
+inline val U16.ui: UInt
+    get() = toUInt()
+inline val U16.ul: ULong
+    get() = toULong()
+inline val U16.f32: F32
+    get() = toFloat()
+inline val U16.f: F32
+    get() = f32
+inline val U16.f64: F64
+    get() = toDouble()
+inline val U32.i8: I8
+    get() = toByte()
+inline val U32.i16: I16
+    get() = toShort()
+inline val U32.i32: I32
+    get() = toInt()
+inline val U32.i: I32
+    get() = i32
+inline val U32.i64: I64
+    get() = toLong()
+inline val U32.L: I64
+    get() = i64
+inline val U32.u8: U8
+    get() = U8(this)
+inline val U32.u16: U16
+    get() = U16(this)
+inline val U32.u64: U64
+    get() = U64(this)
+inline val U32.bigInt: BigInt
+    get() = toBigInt()
+inline val U32.ub: UByte
+    get() = toUByte()
+inline val U32.us: UShort
+    get() = toUShort()
+inline val U32.ui: UInt
+    get() = toUInt()
+inline val U32.ul: ULong
+    get() = toULong()
+inline val U32.f32: F32
+    get() = toFloat()
+inline val U32.f: F32
+    get() = f32
+inline val U32.f64: F64
+    get() = toDouble()
+inline val U64.i8: I8
+    get() = toByte()
+inline val U64.i16: I16
+    get() = toShort()
+inline val U64.i32: I32
+    get() = toInt()
+inline val U64.i: I32
+    get() = i32
+inline val U64.i64: I64
+    get() = toLong()
+inline val U64.L: I64
+    get() = i64
+inline val U64.u8: U8
+    get() = U8(this)
+inline val U64.u16: U16
+    get() = U16(this)
+inline val U64.u32: U32
+    get() = U32(this)
+inline val U64.bigInt: BigInt
+    get() = toBigInt()
+inline val U64.ub: UByte
+    get() = toUByte()
+inline val U64.us: UShort
+    get() = toUShort()
+inline val U64.ui: UInt
+    get() = toUInt()
+inline val U64.ul: ULong
+    get() = toULong()
+inline val U64.f32: F32
+    get() = toFloat()
+inline val U64.f: F32
+    get() = f32
+inline val U64.f64: F64
+    get() = toDouble()
+inline val BigInt.i8: I8
+    get() = byteValue()
+inline val BigInt.i16: I16
+    get() = shortValue()
+inline val BigInt.i32: I32
+    get() = intValue()
+inline val BigInt.i: I32
+    get() = i32
+inline val BigInt.i64: I64
+    get() = longValue()
+inline val BigInt.L: I64
+    get() = i64
+inline val BigInt.u8: U8
+    get() = U8(ubyteValue())
+inline val BigInt.u16: U16
+    get() = U16(ushortValue())
+inline val BigInt.u32: U32
+    get() = U32(uintValue())
+inline val BigInt.u64: U64
+    get() = U64(ulongValue())
+inline val BigInt.ub: UByte
+    get() = ubyteValue()
+inline val BigInt.us: UShort
+    get() = ushortValue()
+inline val BigInt.ui: UInt
+    get() = uintValue()
+inline val BigInt.ul: ULong
+    get() = ulongValue()
+inline val BigInt.f32: F32
+    get() = floatValue()
+inline val BigInt.f: F32
+    get() = f32
+inline val BigInt.f64: F64
+    get() = doubleValue()
+inline val UByte.i8: I8
+    get() = toByte()
+inline val UByte.i16: I16
+    get() = toShort()
+inline val UByte.i32: I32
+    get() = toInt()
+inline val UByte.i: I32
+    get() = i32
+inline val UByte.i64: I64
+    get() = toLong()
+inline val UByte.L: I64
+    get() = i64
+inline val UByte.u8: U8
+    get() = U8(this)
+inline val UByte.u16: U16
+    get() = U16(this)
+inline val UByte.u32: U32
+    get() = U32(this)
+inline val UByte.u64: U64
+    get() = U64(this)
+inline val UByte.bigInt: BigInt
+    get() = toBigInteger()
+inline val UByte.us: UShort
+    get() = toUShort()
+inline val UByte.ui: UInt
+    get() = toUInt()
+inline val UByte.ul: ULong
+    get() = toULong()
+inline val UByte.f32: F32
+    get() = toFloat()
+inline val UByte.f: F32
+    get() = f32
+inline val UByte.f64: F64
+    get() = toDouble()
+inline val UShort.i8: I8
+    get() = toByte()
+inline val UShort.i16: I16
+    get() = toShort()
+inline val UShort.i32: I32
+    get() = toInt()
+inline val UShort.i: I32
+    get() = i32
+inline val UShort.i64: I64
+    get() = toLong()
+inline val UShort.L: I64
+    get() = i64
+inline val UShort.u8: U8
+    get() = U8(this)
+inline val UShort.u16: U16
+    get() = U16(this)
+inline val UShort.u32: U32
+    get() = U32(this)
+inline val UShort.u64: U64
+    get() = U64(this)
+inline val UShort.bigInt: BigInt
+    get() = toBigInteger()
+inline val UShort.ub: UByte
+    get() = toUByte()
+inline val UShort.ui: UInt
+    get() = toUInt()
+inline val UShort.ul: ULong
+    get() = toULong()
+inline val UShort.f32: F32
+    get() = toFloat()
+inline val UShort.f: F32
+    get() = f32
+inline val UShort.f64: F64
+    get() = toDouble()
+inline val UInt.i8: I8
+    get() = toByte()
+inline val UInt.i16: I16
+    get() = toShort()
+inline val UInt.i32: I32
+    get() = toInt()
+inline val UInt.i: I32
+    get() = i32
+inline val UInt.i64: I64
+    get() = toLong()
+inline val UInt.L: I64
+    get() = i64
+inline val UInt.u8: U8
+    get() = U8(this)
+inline val UInt.u16: U16
+    get() = U16(this)
+inline val UInt.u32: U32
+    get() = U32(this)
+inline val UInt.u64: U64
+    get() = U64(this)
+inline val UInt.bigInt: BigInt
+    get() = toBigInteger()
+inline val UInt.ub: UByte
+    get() = toUByte()
+inline val UInt.us: UShort
+    get() = toUShort()
+inline val UInt.ul: ULong
+    get() = toULong()
+inline val UInt.f32: F32
+    get() = toFloat()
+inline val UInt.f: F32
+    get() = f32
+inline val UInt.f64: F64
+    get() = toDouble()
+inline val ULong.i8: I8
+    get() = toByte()
+inline val ULong.i16: I16
+    get() = toShort()
+inline val ULong.i32: I32
+    get() = toInt()
+inline val ULong.i: I32
+    get() = i32
+inline val ULong.i64: I64
+    get() = toLong()
+inline val ULong.L: I64
+    get() = i64
+inline val ULong.u8: U8
+    get() = U8(this)
+inline val ULong.u16: U16
+    get() = U16(this)
+inline val ULong.u32: U32
+    get() = U32(this)
+inline val ULong.u64: U64
+    get() = U64(this)
+inline val ULong.bigInt: BigInt
+    get() = toBigInteger()
+inline val ULong.ub: UByte
+    get() = toUByte()
+inline val ULong.us: UShort
+    get() = toUShort()
+inline val ULong.ui: UInt
+    get() = toUInt()
+inline val ULong.f32: F32
+    get() = toFloat()
+inline val ULong.f: F32
+    get() = f32
+inline val ULong.f64: F64
+    get() = toDouble()
diff --git a/src/genCommonMain/kotlin/uns/operators.kt b/src/genCommonMain/kotlin/uns/operators.kt
new file mode 100644
index 0000000..1506e8e
--- /dev/null
+++ b/src/genCommonMain/kotlin/uns/operators.kt
@@ -0,0 +1,381 @@
+@file:Suppress("NOTHING_TO_INLINE")
+package uns
+
+import com.ionspin.kotlin.bignum.integer.toBigInteger
+
+inline infix operator fun Byte.plus(other: U8): U8 = U8(this.toUByte() + other.v)
+inline infix operator fun Byte.plus(other: U16): U16 = U16(this.toUByte() + other.v)
+inline infix operator fun Byte.plus(other: U32): U32 = U32(this.toUByte() + other.v)
+inline infix operator fun Byte.plus(other: U64): U64 = U64(this.toUByte() + other.v)
+inline infix operator fun Byte.minus(other: U8): U8 = U8(this.toUByte() - other.v)
+inline infix operator fun Byte.minus(other: U16): U16 = U16(this.toUByte() - other.v)
+inline infix operator fun Byte.minus(other: U32): U32 = U32(this.toUByte() - other.v)
+inline infix operator fun Byte.minus(other: U64): U64 = U64(this.toUByte() - other.v)
+inline infix operator fun Byte.times(other: U8): U8 = U8(this.toUByte() * other.v)
+inline infix operator fun Byte.times(other: U16): U16 = U16(this.toUByte() * other.v)
+inline infix operator fun Byte.times(other: U32): U32 = U32(this.toUByte() * other.v)
+inline infix operator fun Byte.times(other: U64): U64 = U64(this.toUByte() * other.v)
+inline infix operator fun Byte.div(other: U8): U8 = U8(this.toUByte() / other.v)
+inline infix operator fun Byte.div(other: U16): U16 = U16(this.toUByte() / other.v)
+inline infix operator fun Byte.div(other: U32): U32 = U32(this.toUByte() / other.v)
+inline infix operator fun Byte.div(other: U64): U64 = U64(this.toUByte() / other.v)
+inline infix operator fun Byte.rem(other: U8): U8 = U8(this.toUByte() % other.v)
+inline infix operator fun Byte.rem(other: U16): U16 = U16(this.toUByte() % other.v)
+inline infix operator fun Byte.rem(other: U32): U32 = U32(this.toUByte() % other.v)
+inline infix operator fun Byte.rem(other: U64): U64 = U64(this.toUByte() % other.v)
+inline infix operator fun Short.plus(other: U8): Short = (this + other.toShort()).toShort()
+inline infix operator fun Short.plus(other: U16): U16 = U16(this.toUShort() + other.v)
+inline infix operator fun Short.plus(other: U32): U32 = U32(this.toUShort() + other.v)
+inline infix operator fun Short.plus(other: U64): U64 = U64(this.toUShort() + other.v)
+inline infix operator fun Short.minus(other: U8): Short = (this - other.toShort()).toShort()
+inline infix operator fun Short.minus(other: U16): U16 = U16(this.toUShort() - other.v)
+inline infix operator fun Short.minus(other: U32): U32 = U32(this.toUShort() - other.v)
+inline infix operator fun Short.minus(other: U64): U64 = U64(this.toUShort() - other.v)
+inline infix operator fun Short.times(other: U8): Short = (this * other.toShort()).toShort()
+inline infix operator fun Short.times(other: U16): U16 = U16(this.toUShort() * other.v)
+inline infix operator fun Short.times(other: U32): U32 = U32(this.toUShort() * other.v)
+inline infix operator fun Short.times(other: U64): U64 = U64(this.toUShort() * other.v)
+inline infix operator fun Short.div(other: U8): Short = (this / other.toShort()).toShort()
+inline infix operator fun Short.div(other: U16): U16 = U16(this.toUShort() / other.v)
+inline infix operator fun Short.div(other: U32): U32 = U32(this.toUShort() / other.v)
+inline infix operator fun Short.div(other: U64): U64 = U64(this.toUShort() / other.v)
+inline infix operator fun Short.rem(other: U8): Short = (this % other.toShort()).toShort()
+inline infix operator fun Short.rem(other: U16): U16 = U16(this.toUShort() % other.v)
+inline infix operator fun Short.rem(other: U32): U32 = U32(this.toUShort() % other.v)
+inline infix operator fun Short.rem(other: U64): U64 = U64(this.toUShort() % other.v)
+inline infix operator fun Int.plus(other: U8): Int = this + other.toInt()
+inline infix operator fun Int.plus(other: U16): Int = this + other.toInt()
+inline infix operator fun Int.plus(other: U32): U32 = U32(this.toUInt() + other.v)
+inline infix operator fun Int.plus(other: U64): U64 = U64(this.toUInt() + other.v)
+inline infix operator fun Int.minus(other: U8): Int = this - other.toInt()
+inline infix operator fun Int.minus(other: U16): Int = this - other.toInt()
+inline infix operator fun Int.minus(other: U32): U32 = U32(this.toUInt() - other.v)
+inline infix operator fun Int.minus(other: U64): U64 = U64(this.toUInt() - other.v)
+inline infix operator fun Int.times(other: U8): Int = this * other.toInt()
+inline infix operator fun Int.times(other: U16): Int = this * other.toInt()
+inline infix operator fun Int.times(other: U32): U32 = U32(this.toUInt() * other.v)
+inline infix operator fun Int.times(other: U64): U64 = U64(this.toUInt() * other.v)
+inline infix operator fun Int.div(other: U8): Int = this / other.toInt()
+inline infix operator fun Int.div(other: U16): Int = this / other.toInt()
+inline infix operator fun Int.div(other: U32): U32 = U32(this.toUInt() / other.v)
+inline infix operator fun Int.div(other: U64): U64 = U64(this.toUInt() / other.v)
+inline infix operator fun Int.rem(other: U8): Int = this % other.toInt()
+inline infix operator fun Int.rem(other: U16): Int = this % other.toInt()
+inline infix operator fun Int.rem(other: U32): U32 = U32(this.toUInt() % other.v)
+inline infix operator fun Int.rem(other: U64): U64 = U64(this.toUInt() % other.v)
+inline infix operator fun Long.plus(other: U8): Long = this + other.toLong()
+inline infix operator fun Long.plus(other: U16): Long = this + other.toLong()
+inline infix operator fun Long.plus(other: U32): Long = this + other.toLong()
+inline infix operator fun Long.plus(other: U64): U64 = U64(this.toULong() + other.v)
+inline infix operator fun Long.minus(other: U8): Long = this - other.toLong()
+inline infix operator fun Long.minus(other: U16): Long = this - other.toLong()
+inline infix operator fun Long.minus(other: U32): Long = this - other.toLong()
+inline infix operator fun Long.minus(other: U64): U64 = U64(this.toULong() - other.v)
+inline infix operator fun Long.times(other: U8): Long = this * other.toLong()
+inline infix operator fun Long.times(other: U16): Long = this * other.toLong()
+inline infix operator fun Long.times(other: U32): Long = this * other.toLong()
+inline infix operator fun Long.times(other: U64): U64 = U64(this.toULong() * other.v)
+inline infix operator fun Long.div(other: U8): Long = this / other.toLong()
+inline infix operator fun Long.div(other: U16): Long = this / other.toLong()
+inline infix operator fun Long.div(other: U32): Long = this / other.toLong()
+inline infix operator fun Long.div(other: U64): U64 = U64(this.toULong() / other.v)
+inline infix operator fun Long.rem(other: U8): Long = this % other.toLong()
+inline infix operator fun Long.rem(other: U16): Long = this % other.toLong()
+inline infix operator fun Long.rem(other: U32): Long = this % other.toLong()
+inline infix operator fun Long.rem(other: U64): U64 = U64(this.toULong() % other.v)
+inline infix operator fun BigInt.plus(other: U8): BigInt = this + other.toBigInt()
+inline infix operator fun BigInt.plus(other: U16): BigInt = this + other.toBigInt()
+inline infix operator fun BigInt.plus(other: U32): BigInt = this + other.toBigInt()
+inline infix operator fun BigInt.plus(other: U64): BigInt = this + other.toBigInt()
+inline infix operator fun BigInt.minus(other: U8): BigInt = this - other.toBigInt()
+inline infix operator fun BigInt.minus(other: U16): BigInt = this - other.toBigInt()
+inline infix operator fun BigInt.minus(other: U32): BigInt = this - other.toBigInt()
+inline infix operator fun BigInt.minus(other: U64): BigInt = this - other.toBigInt()
+inline infix operator fun BigInt.times(other: U8): BigInt = this * other.toBigInt()
+inline infix operator fun BigInt.times(other: U16): BigInt = this * other.toBigInt()
+inline infix operator fun BigInt.times(other: U32): BigInt = this * other.toBigInt()
+inline infix operator fun BigInt.times(other: U64): BigInt = this * other.toBigInt()
+inline infix operator fun BigInt.div(other: U8): BigInt = this / other.toBigInt()
+inline infix operator fun BigInt.div(other: U16): BigInt = this / other.toBigInt()
+inline infix operator fun BigInt.div(other: U32): BigInt = this / other.toBigInt()
+inline infix operator fun BigInt.div(other: U64): BigInt = this / other.toBigInt()
+inline infix operator fun BigInt.rem(other: U8): BigInt = this % other.toBigInt()
+inline infix operator fun BigInt.rem(other: U16): BigInt = this % other.toBigInt()
+inline infix operator fun BigInt.rem(other: U32): BigInt = this % other.toBigInt()
+inline infix operator fun BigInt.rem(other: U64): BigInt = this % other.toBigInt()
+inline infix operator fun UByte.plus(other: U8): U8 = U8(this + other.v)
+inline infix operator fun UByte.plus(other: U16): U16 = U16(this + other.v)
+inline infix operator fun UByte.plus(other: U32): U32 = U32(this + other.v)
+inline infix operator fun UByte.plus(other: U64): U64 = U64(this + other.v)
+inline infix operator fun UByte.minus(other: U8): U8 = U8(this - other.v)
+inline infix operator fun UByte.minus(other: U16): U16 = U16(this - other.v)
+inline infix operator fun UByte.minus(other: U32): U32 = U32(this - other.v)
+inline infix operator fun UByte.minus(other: U64): U64 = U64(this - other.v)
+inline infix operator fun UByte.times(other: U8): U8 = U8(this * other.v)
+inline infix operator fun UByte.times(other: U16): U16 = U16(this * other.v)
+inline infix operator fun UByte.times(other: U32): U32 = U32(this * other.v)
+inline infix operator fun UByte.times(other: U64): U64 = U64(this * other.v)
+inline infix operator fun UByte.div(other: U8): U8 = U8(this / other.v)
+inline infix operator fun UByte.div(other: U16): U16 = U16(this / other.v)
+inline infix operator fun UByte.div(other: U32): U32 = U32(this / other.v)
+inline infix operator fun UByte.div(other: U64): U64 = U64(this / other.v)
+inline infix operator fun UByte.rem(other: U8): U8 = U8(this % other.v)
+inline infix operator fun UByte.rem(other: U16): U16 = U16(this % other.v)
+inline infix operator fun UByte.rem(other: U32): U32 = U32(this % other.v)
+inline infix operator fun UByte.rem(other: U64): U64 = U64(this % other.v)
+inline infix operator fun UShort.plus(other: U8): UShort = (this + other.v).toUShort()
+inline infix operator fun UShort.plus(other: U16): U16 = U16(this + other.v)
+inline infix operator fun UShort.plus(other: U32): U32 = U32(this + other.v)
+inline infix operator fun UShort.plus(other: U64): U64 = U64(this + other.v)
+inline infix operator fun UShort.minus(other: U8): UShort = (this - other.v).toUShort()
+inline infix operator fun UShort.minus(other: U16): U16 = U16(this - other.v)
+inline infix operator fun UShort.minus(other: U32): U32 = U32(this - other.v)
+inline infix operator fun UShort.minus(other: U64): U64 = U64(this - other.v)
+inline infix operator fun UShort.times(other: U8): UShort = (this * other.v).toUShort()
+inline infix operator fun UShort.times(other: U16): U16 = U16(this * other.v)
+inline infix operator fun UShort.times(other: U32): U32 = U32(this * other.v)
+inline infix operator fun UShort.times(other: U64): U64 = U64(this * other.v)
+inline infix operator fun UShort.div(other: U8): UShort = (this / other.v).toUShort()
+inline infix operator fun UShort.div(other: U16): U16 = U16(this / other.v)
+inline infix operator fun UShort.div(other: U32): U32 = U32(this / other.v)
+inline infix operator fun UShort.div(other: U64): U64 = U64(this / other.v)
+inline infix operator fun UShort.rem(other: U8): UShort = (this % other.v).toUShort()
+inline infix operator fun UShort.rem(other: U16): U16 = U16(this % other.v)
+inline infix operator fun UShort.rem(other: U32): U32 = U32(this % other.v)
+inline infix operator fun UShort.rem(other: U64): U64 = U64(this % other.v)
+inline infix operator fun UInt.plus(other: U8): UInt = this + other.v
+inline infix operator fun UInt.plus(other: U16): UInt = this + other.v
+inline infix operator fun UInt.plus(other: U32): U32 = U32(this + other.v)
+inline infix operator fun UInt.plus(other: U64): U64 = U64(this + other.v)
+inline infix operator fun UInt.minus(other: U8): UInt = this - other.v
+inline infix operator fun UInt.minus(other: U16): UInt = this - other.v
+inline infix operator fun UInt.minus(other: U32): U32 = U32(this - other.v)
+inline infix operator fun UInt.minus(other: U64): U64 = U64(this - other.v)
+inline infix operator fun UInt.times(other: U8): UInt = this * other.v
+inline infix operator fun UInt.times(other: U16): UInt = this * other.v
+inline infix operator fun UInt.times(other: U32): U32 = U32(this * other.v)
+inline infix operator fun UInt.times(other: U64): U64 = U64(this * other.v)
+inline infix operator fun UInt.div(other: U8): UInt = this / other.v
+inline infix operator fun UInt.div(other: U16): UInt = this / other.v
+inline infix operator fun UInt.div(other: U32): U32 = U32(this / other.v)
+inline infix operator fun UInt.div(other: U64): U64 = U64(this / other.v)
+inline infix operator fun UInt.rem(other: U8): UInt = this % other.v
+inline infix operator fun UInt.rem(other: U16): UInt = this % other.v
+inline infix operator fun UInt.rem(other: U32): U32 = U32(this % other.v)
+inline infix operator fun UInt.rem(other: U64): U64 = U64(this % other.v)
+inline infix operator fun ULong.plus(other: U8): ULong = this + other.v
+inline infix operator fun ULong.plus(other: U16): ULong = this + other.v
+inline infix operator fun ULong.plus(other: U32): ULong = this + other.v
+inline infix operator fun ULong.plus(other: U64): U64 = U64(this + other.v)
+inline infix operator fun ULong.minus(other: U8): ULong = this - other.v
+inline infix operator fun ULong.minus(other: U16): ULong = this - other.v
+inline infix operator fun ULong.minus(other: U32): ULong = this - other.v
+inline infix operator fun ULong.minus(other: U64): U64 = U64(this - other.v)
+inline infix operator fun ULong.times(other: U8): ULong = this * other.v
+inline infix operator fun ULong.times(other: U16): ULong = this * other.v
+inline infix operator fun ULong.times(other: U32): ULong = this * other.v
+inline infix operator fun ULong.times(other: U64): U64 = U64(this * other.v)
+inline infix operator fun ULong.div(other: U8): ULong = this / other.v
+inline infix operator fun ULong.div(other: U16): ULong = this / other.v
+inline infix operator fun ULong.div(other: U32): ULong = this / other.v
+inline infix operator fun ULong.div(other: U64): U64 = U64(this / other.v)
+inline infix operator fun ULong.rem(other: U8): ULong = this % other.v
+inline infix operator fun ULong.rem(other: U16): ULong = this % other.v
+inline infix operator fun ULong.rem(other: U32): ULong = this % other.v
+inline infix operator fun ULong.rem(other: U64): U64 = U64(this % other.v)
+inline infix fun Byte.and(other: U8): Byte = (this.toUByte() and other.v).toByte()
+inline infix fun Byte.and(other: U16): Byte = (this.toUByte() and other.v.toUByte()).toByte()
+inline infix fun Byte.and(other: U32): Byte = (this.toUByte() and other.v.toUByte()).toByte()
+inline infix fun Byte.and(other: U64): Byte = (this.toUByte() and other.v.toUByte()).toByte()
+inline infix fun Byte.or(other: U8): Byte = (this.toUByte() or other.v).toByte()
+inline infix fun Byte.or(other: U16): Byte = (this.toUByte() or other.v.toUByte()).toByte()
+inline infix fun Byte.or(other: U32): Byte = (this.toUByte() or other.v.toUByte()).toByte()
+inline infix fun Byte.or(other: U64): Byte = (this.toUByte() or other.v.toUByte()).toByte()
+inline infix fun Byte.xor(other: U8): Byte = (this.toUByte() xor other.v).toByte()
+inline infix fun Byte.xor(other: U16): Byte = (this.toUByte() xor other.v.toUByte()).toByte()
+inline infix fun Byte.xor(other: U32): Byte = (this.toUByte() xor other.v.toUByte()).toByte()
+inline infix fun Byte.xor(other: U64): Byte = (this.toUByte() xor other.v.toUByte()).toByte()
+inline infix fun Byte.shl(other: U8): Byte = (this.toUByte().toUInt() shl other.v.toInt()).toByte()
+inline infix fun Byte.shl(other: U16): Byte = (this.toUByte().toUInt() shl other.v.toInt()).toByte()
+inline infix fun Byte.shl(other: U32): Byte = (this.toUByte().toUInt() shl other.v.toInt()).toByte()
+inline infix fun Byte.shl(other: U64): Byte = (this.toUByte().toUInt() shl other.v.toInt()).toByte()
+inline infix fun Byte.shr(other: U8): Byte = (this.toUByte().toUInt() shr other.v.toInt()).toByte()
+inline infix fun Byte.shr(other: U16): Byte = (this.toUByte().toUInt() shr other.v.toInt()).toByte()
+inline infix fun Byte.shr(other: U32): Byte = (this.toUByte().toUInt() shr other.v.toInt()).toByte()
+inline infix fun Byte.shr(other: U64): Byte = (this.toUByte().toUInt() shr other.v.toInt()).toByte()
+inline infix fun Short.and(other: U8): Short = (this.toUShort() and other.v.toUShort()).toShort()
+inline infix fun Short.and(other: U16): Short = (this.toUShort() and other.v).toShort()
+inline infix fun Short.and(other: U32): Short = (this.toUShort() and other.v.toUShort()).toShort()
+inline infix fun Short.and(other: U64): Short = (this.toUShort() and other.v.toUShort()).toShort()
+inline infix fun Short.or(other: U8): Short = (this.toUShort() or other.v.toUShort()).toShort()
+inline infix fun Short.or(other: U16): Short = (this.toUShort() or other.v).toShort()
+inline infix fun Short.or(other: U32): Short = (this.toUShort() or other.v.toUShort()).toShort()
+inline infix fun Short.or(other: U64): Short = (this.toUShort() or other.v.toUShort()).toShort()
+inline infix fun Short.xor(other: U8): Short = (this.toUShort() xor other.v.toUShort()).toShort()
+inline infix fun Short.xor(other: U16): Short = (this.toUShort() xor other.v).toShort()
+inline infix fun Short.xor(other: U32): Short = (this.toUShort() xor other.v.toUShort()).toShort()
+inline infix fun Short.xor(other: U64): Short = (this.toUShort() xor other.v.toUShort()).toShort()
+inline infix fun Short.shl(other: U8): Short = (this.toUShort().toUInt() shl other.v.toInt()).toShort()
+inline infix fun Short.shl(other: U16): Short = (this.toUShort().toUInt() shl other.v.toInt()).toShort()
+inline infix fun Short.shl(other: U32): Short = (this.toUShort().toUInt() shl other.v.toInt()).toShort()
+inline infix fun Short.shl(other: U64): Short = (this.toUShort().toUInt() shl other.v.toInt()).toShort()
+inline infix fun Short.shr(other: U8): Short = (this.toUShort().toUInt() shr other.v.toInt()).toShort()
+inline infix fun Short.shr(other: U16): Short = (this.toUShort().toUInt() shr other.v.toInt()).toShort()
+inline infix fun Short.shr(other: U32): Short = (this.toUShort().toUInt() shr other.v.toInt()).toShort()
+inline infix fun Short.shr(other: U64): Short = (this.toUShort().toUInt() shr other.v.toInt()).toShort()
+inline infix fun Int.and(other: U8): Int = (this.toUInt() and other.v.toUInt()).toInt()
+inline infix fun Int.and(other: U16): Int = (this.toUInt() and other.v.toUInt()).toInt()
+inline infix fun Int.and(other: U32): Int = (this.toUInt() and other.v).toInt()
+inline infix fun Int.and(other: U64): Int = (this.toUInt() and other.v.toUInt()).toInt()
+inline infix fun Int.or(other: U8): Int = (this.toUInt() or other.v.toUInt()).toInt()
+inline infix fun Int.or(other: U16): Int = (this.toUInt() or other.v.toUInt()).toInt()
+inline infix fun Int.or(other: U32): Int = (this.toUInt() or other.v).toInt()
+inline infix fun Int.or(other: U64): Int = (this.toUInt() or other.v.toUInt()).toInt()
+inline infix fun Int.xor(other: U8): Int = (this.toUInt() xor other.v.toUInt()).toInt()
+inline infix fun Int.xor(other: U16): Int = (this.toUInt() xor other.v.toUInt()).toInt()
+inline infix fun Int.xor(other: U32): Int = (this.toUInt() xor other.v).toInt()
+inline infix fun Int.xor(other: U64): Int = (this.toUInt() xor other.v.toUInt()).toInt()
+inline infix fun Int.shl(other: U8): Int = this shl other.v.toInt()
+inline infix fun Int.shl(other: U16): Int = this shl other.v.toInt()
+inline infix fun Int.shl(other: U32): Int = this shl other.v.toInt()
+inline infix fun Int.shl(other: U64): Int = this shl other.v.toInt()
+inline infix fun Int.shr(other: U8): Int = this shr other.v.toInt()
+inline infix fun Int.shr(other: U16): Int = this shr other.v.toInt()
+inline infix fun Int.shr(other: U32): Int = this shr other.v.toInt()
+inline infix fun Int.shr(other: U64): Int = this shr other.v.toInt()
+inline infix fun Long.and(other: U8): Long = (this.toULong() and other.v.toULong()).toLong()
+inline infix fun Long.and(other: U16): Long = (this.toULong() and other.v.toULong()).toLong()
+inline infix fun Long.and(other: U32): Long = (this.toULong() and other.v.toULong()).toLong()
+inline infix fun Long.and(other: U64): Long = (this.toULong() and other.v).toLong()
+inline infix fun Long.or(other: U8): Long = (this.toULong() or other.v.toULong()).toLong()
+inline infix fun Long.or(other: U16): Long = (this.toULong() or other.v.toULong()).toLong()
+inline infix fun Long.or(other: U32): Long = (this.toULong() or other.v.toULong()).toLong()
+inline infix fun Long.or(other: U64): Long = (this.toULong() or other.v).toLong()
+inline infix fun Long.xor(other: U8): Long = (this.toULong() xor other.v.toULong()).toLong()
+inline infix fun Long.xor(other: U16): Long = (this.toULong() xor other.v.toULong()).toLong()
+inline infix fun Long.xor(other: U32): Long = (this.toULong() xor other.v.toULong()).toLong()
+inline infix fun Long.xor(other: U64): Long = (this.toULong() xor other.v).toLong()
+inline infix fun Long.shl(other: U8): Long = this shl other.v.toInt()
+inline infix fun Long.shl(other: U16): Long = this shl other.v.toInt()
+inline infix fun Long.shl(other: U32): Long = this shl other.v.toInt()
+inline infix fun Long.shl(other: U64): Long = this shl other.v.toInt()
+inline infix fun Long.shr(other: U8): Long = this shr other.v.toInt()
+inline infix fun Long.shr(other: U16): Long = this shr other.v.toInt()
+inline infix fun Long.shr(other: U32): Long = this shr other.v.toInt()
+inline infix fun Long.shr(other: U64): Long = this shr other.v.toInt()
+inline infix fun BigInt.and(other: U8): BigInt = this and other.v.toBigInteger()
+inline infix fun BigInt.and(other: U16): BigInt = this and other.v.toBigInteger()
+inline infix fun BigInt.and(other: U32): BigInt = this and other.v.toBigInteger()
+inline infix fun BigInt.and(other: U64): BigInt = this and other.v.toBigInteger()
+inline infix fun BigInt.or(other: U8): BigInt = this or other.v.toBigInteger()
+inline infix fun BigInt.or(other: U16): BigInt = this or other.v.toBigInteger()
+inline infix fun BigInt.or(other: U32): BigInt = this or other.v.toBigInteger()
+inline infix fun BigInt.or(other: U64): BigInt = this or other.v.toBigInteger()
+inline infix fun BigInt.xor(other: U8): BigInt = this xor other.v.toBigInteger()
+inline infix fun BigInt.xor(other: U16): BigInt = this xor other.v.toBigInteger()
+inline infix fun BigInt.xor(other: U32): BigInt = this xor other.v.toBigInteger()
+inline infix fun BigInt.xor(other: U64): BigInt = this xor other.v.toBigInteger()
+inline infix fun BigInt.shl(other: U8): BigInt = this shl other.v.toInt()
+inline infix fun BigInt.shl(other: U16): BigInt = this shl other.v.toInt()
+inline infix fun BigInt.shl(other: U32): BigInt = this shl other.v.toInt()
+inline infix fun BigInt.shl(other: U64): BigInt = this shl other.v.toInt()
+inline infix fun BigInt.shr(other: U8): BigInt = this shr other.v.toInt()
+inline infix fun BigInt.shr(other: U16): BigInt = this shr other.v.toInt()
+inline infix fun BigInt.shr(other: U32): BigInt = this shr other.v.toInt()
+inline infix fun BigInt.shr(other: U64): BigInt = this shr other.v.toInt()
+inline infix fun UByte.and(other: U8): UByte = this and other.v
+inline infix fun UByte.and(other: U16): UByte = this and other.v.toUByte()
+inline infix fun UByte.and(other: U32): UByte = this and other.v.toUByte()
+inline infix fun UByte.and(other: U64): UByte = this and other.v.toUByte()
+inline infix fun UByte.or(other: U8): UByte = this or other.v
+inline infix fun UByte.or(other: U16): UByte = this or other.v.toUByte()
+inline infix fun UByte.or(other: U32): UByte = this or other.v.toUByte()
+inline infix fun UByte.or(other: U64): UByte = this or other.v.toUByte()
+inline infix fun UByte.xor(other: U8): UByte = this xor other.v
+inline infix fun UByte.xor(other: U16): UByte = this xor other.v.toUByte()
+inline infix fun UByte.xor(other: U32): UByte = this xor other.v.toUByte()
+inline infix fun UByte.xor(other: U64): UByte = this xor other.v.toUByte()
+inline infix fun UByte.shl(other: U8): UByte = (this.toUInt() shl other.v.toInt()).toUByte()
+inline infix fun UByte.shl(other: U16): UByte = (this.toUInt() shl other.v.toInt()).toUByte()
+inline infix fun UByte.shl(other: U32): UByte = (this.toUInt() shl other.v.toInt()).toUByte()
+inline infix fun UByte.shl(other: U64): UByte = (this.toUInt() shl other.v.toInt()).toUByte()
+inline infix fun UByte.shr(other: U8): UByte = (this.toUInt() shr other.v.toInt()).toUByte()
+inline infix fun UByte.shr(other: U16): UByte = (this.toUInt() shr other.v.toInt()).toUByte()
+inline infix fun UByte.shr(other: U32): UByte = (this.toUInt() shr other.v.toInt()).toUByte()
+inline infix fun UByte.shr(other: U64): UByte = (this.toUInt() shr other.v.toInt()).toUByte()
+infix operator fun UByte.compareTo(other: U8): Int = toUByte().compareTo(other.v)
+infix operator fun UByte.compareTo(other: U16): Int = toUByte().compareTo(other.v)
+infix operator fun UByte.compareTo(other: U32): Int = toUByte().compareTo(other.v)
+infix operator fun UByte.compareTo(other: U64): Int = toUByte().compareTo(other.v)
+inline infix fun UShort.and(other: U8): UShort = this and other.v.toUShort()
+inline infix fun UShort.and(other: U16): UShort = this and other.v
+inline infix fun UShort.and(other: U32): UShort = this and other.v.toUShort()
+inline infix fun UShort.and(other: U64): UShort = this and other.v.toUShort()
+inline infix fun UShort.or(other: U8): UShort = this or other.v.toUShort()
+inline infix fun UShort.or(other: U16): UShort = this or other.v
+inline infix fun UShort.or(other: U32): UShort = this or other.v.toUShort()
+inline infix fun UShort.or(other: U64): UShort = this or other.v.toUShort()
+inline infix fun UShort.xor(other: U8): UShort = this xor other.v.toUShort()
+inline infix fun UShort.xor(other: U16): UShort = this xor other.v
+inline infix fun UShort.xor(other: U32): UShort = this xor other.v.toUShort()
+inline infix fun UShort.xor(other: U64): UShort = this xor other.v.toUShort()
+inline infix fun UShort.shl(other: U8): UShort = (this.toUInt() shl other.v.toInt()).toUShort()
+inline infix fun UShort.shl(other: U16): UShort = (this.toUInt() shl other.v.toInt()).toUShort()
+inline infix fun UShort.shl(other: U32): UShort = (this.toUInt() shl other.v.toInt()).toUShort()
+inline infix fun UShort.shl(other: U64): UShort = (this.toUInt() shl other.v.toInt()).toUShort()
+inline infix fun UShort.shr(other: U8): UShort = (this.toUInt() shr other.v.toInt()).toUShort()
+inline infix fun UShort.shr(other: U16): UShort = (this.toUInt() shr other.v.toInt()).toUShort()
+inline infix fun UShort.shr(other: U32): UShort = (this.toUInt() shr other.v.toInt()).toUShort()
+inline infix fun UShort.shr(other: U64): UShort = (this.toUInt() shr other.v.toInt()).toUShort()
+infix operator fun UShort.compareTo(other: U8): Int = toUShort().compareTo(other.v)
+infix operator fun UShort.compareTo(other: U16): Int = toUShort().compareTo(other.v)
+infix operator fun UShort.compareTo(other: U32): Int = toUShort().compareTo(other.v)
+infix operator fun UShort.compareTo(other: U64): Int = toUShort().compareTo(other.v)
+inline infix fun UInt.and(other: U8): UInt = this and other.v.toUInt()
+inline infix fun UInt.and(other: U16): UInt = this and other.v.toUInt()
+inline infix fun UInt.and(other: U32): UInt = this and other.v
+inline infix fun UInt.and(other: U64): UInt = this and other.v.toUInt()
+inline infix fun UInt.or(other: U8): UInt = this or other.v.toUInt()
+inline infix fun UInt.or(other: U16): UInt = this or other.v.toUInt()
+inline infix fun UInt.or(other: U32): UInt = this or other.v
+inline infix fun UInt.or(other: U64): UInt = this or other.v.toUInt()
+inline infix fun UInt.xor(other: U8): UInt = this xor other.v.toUInt()
+inline infix fun UInt.xor(other: U16): UInt = this xor other.v.toUInt()
+inline infix fun UInt.xor(other: U32): UInt = this xor other.v
+inline infix fun UInt.xor(other: U64): UInt = this xor other.v.toUInt()
+inline infix fun UInt.shl(other: U8): UInt = this shl other.v.toInt()
+inline infix fun UInt.shl(other: U16): UInt = this shl other.v.toInt()
+inline infix fun UInt.shl(other: U32): UInt = this shl other.v.toInt()
+inline infix fun UInt.shl(other: U64): UInt = this shl other.v.toInt()
+inline infix fun UInt.shr(other: U8): UInt = this shr other.v.toInt()
+inline infix fun UInt.shr(other: U16): UInt = this shr other.v.toInt()
+inline infix fun UInt.shr(other: U32): UInt = this shr other.v.toInt()
+inline infix fun UInt.shr(other: U64): UInt = this shr other.v.toInt()
+infix operator fun UInt.compareTo(other: U8): Int = toUInt().compareTo(other.v)
+infix operator fun UInt.compareTo(other: U16): Int = toUInt().compareTo(other.v)
+infix operator fun UInt.compareTo(other: U32): Int = toUInt().compareTo(other.v)
+infix operator fun UInt.compareTo(other: U64): Int = toUInt().compareTo(other.v)
+inline infix fun ULong.and(other: U8): ULong = this and other.v.toULong()
+inline infix fun ULong.and(other: U16): ULong = this and other.v.toULong()
+inline infix fun ULong.and(other: U32): ULong = this and other.v.toULong()
+inline infix fun ULong.and(other: U64): ULong = this and other.v
+inline infix fun ULong.or(other: U8): ULong = this or other.v.toULong()
+inline infix fun ULong.or(other: U16): ULong = this or other.v.toULong()
+inline infix fun ULong.or(other: U32): ULong = this or other.v.toULong()
+inline infix fun ULong.or(other: U64): ULong = this or other.v
+inline infix fun ULong.xor(other: U8): ULong = this xor other.v.toULong()
+inline infix fun ULong.xor(other: U16): ULong = this xor other.v.toULong()
+inline infix fun ULong.xor(other: U32): ULong = this xor other.v.toULong()
+inline infix fun ULong.xor(other: U64): ULong = this xor other.v
+inline infix fun ULong.shl(other: U8): ULong = this shl other.v.toInt()
+inline infix fun ULong.shl(other: U16): ULong = this shl other.v.toInt()
+inline infix fun ULong.shl(other: U32): ULong = this shl other.v.toInt()
+inline infix fun ULong.shl(other: U64): ULong = this shl other.v.toInt()
+inline infix fun ULong.shr(other: U8): ULong = this shr other.v.toInt()
+inline infix fun ULong.shr(other: U16): ULong = this shr other.v.toInt()
+inline infix fun ULong.shr(other: U32): ULong = this shr other.v.toInt()
+inline infix fun ULong.shr(other: U64): ULong = this shr other.v.toInt()
+infix operator fun ULong.compareTo(other: U8): Int = toULong().compareTo(other.v)
+infix operator fun ULong.compareTo(other: U16): Int = toULong().compareTo(other.v)
+infix operator fun ULong.compareTo(other: U32): Int = toULong().compareTo(other.v)
+infix operator fun ULong.compareTo(other: U64): Int = toULong().compareTo(other.v)
diff --git a/src/main/kotlin/module-info b/src/main/kotlin/module-info
deleted file mode 100644
index e4ea9ee..0000000
--- a/src/main/kotlin/module-info
+++ /dev/null
@@ -1,6 +0,0 @@
-module kotlin.graphics.unsigned {
-
-    requires kotlin.stdlib.jdk8;
-
-    exports unsigned;
-}
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/BigInteger.kt b/src/main/kotlin/unsigned/BigInteger.kt
deleted file mode 100644
index f06fcfe..0000000
--- a/src/main/kotlin/unsigned/BigInteger.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-/**
- * Created by GBarbieri on 03.02.2017.
- */
-
-package unsigned
-
-import java.math.BigInteger
-
-
-infix fun BigInteger.ushr(bitCount: Int): BigInteger = shiftRight(bitCount)
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/Byte.kt b/src/main/kotlin/unsigned/Byte.kt
deleted file mode 100644
index e590928..0000000
--- a/src/main/kotlin/unsigned/Byte.kt
+++ /dev/null
@@ -1,109 +0,0 @@
-/**
- * Created by elect on 19/01/2017.
- */
-
-package unsigned
-
-import java.math.BigInteger
-import kotlin.experimental.and
-import kotlin.experimental.or
-import kotlin.experimental.xor
-
-
-fun Byte.toUShort() = toUInt().toShort()
-fun Byte.toUInt() = toInt() and 0xff
-fun Byte.toULong() = toUInt().toLong()
-
-fun Byte.toUbyte() = Ubyte(this)
-fun Byte.toUshort() = Ushort(toUInt())
-fun Byte.toUint() = Uint(toUInt())
-fun Byte.toUlong() = Ulong(toUInt())
-
-fun Byte.toBigInt(): BigInteger = BigInteger.valueOf(toLong())
-fun Byte.toUBigInt(): BigInteger = BigInteger.valueOf(toULong())
-
-val Byte.ub
-    get() = toUbyte()
-val Byte.ui
-    get() = toUint()
-val Byte.ul
-    get() = toUlong()
-val Byte.us
-    get() = toUshort()
-
-infix fun Byte.udiv(b: Byte) = (toUInt() / b.toUInt()).toByte()
-infix fun Byte.urem(b: Byte) = (toUInt() % b.toUInt()).toByte()
-infix fun Byte.ucmp(b: Byte) = toUInt().compareTo(b.toUInt())
-infix fun Byte.ushr(b: Byte) = (toUInt() ushr b.toUInt()).toByte()
-
-infix fun Byte.udiv(b: Short) = (toUInt() / b.toUInt()).toByte()
-infix fun Byte.urem(b: Short) = (toUInt() % b.toUInt()).toByte()
-infix fun Byte.ucmp(b: Short) = toUInt().compareTo(b.toUInt())
-infix fun Byte.ushr(b: Short) = (toUInt() ushr b.toUInt()).toByte()
-
-infix fun Byte.udiv(b: Int) = (toULong() / b.toULong()).toByte()
-infix fun Byte.urem(b: Int) = (toULong() % b.toULong()).toByte()
-infix fun Byte.ucmp(b: Int) = toULong().compareTo(b.toULong())
-infix fun Byte.ushr(b: Int) = (toUInt() ushr b).toByte()
-
-infix fun Byte.udiv(b: Long) = (toBigInt() / b.toBigInt()).toByte()
-infix fun Byte.urem(b: Long) = (toBigInt() % b.toBigInt()).toByte()
-infix fun Byte.ucmp(b: Long) = toBigInt().compareTo(b.toBigInt())
-// no Byte ushr Long
-
-
-operator fun Byte.plus(b: Ubyte) = (this + b.v).toByte()
-operator fun Byte.minus(b: Ubyte) = (this - b.v).toByte()
-operator fun Byte.times(b: Ubyte) = (this * b.v).toByte()
-infix fun Byte.and(b: Ubyte) = this and b.v
-infix fun Byte.or(b: Ubyte) = this or b.v
-infix fun Byte.xor(b: Ubyte) = this xor b.v
-infix fun Byte.shl(b: Ubyte) = (toInt() shl b.toInt()).toByte()
-
-infix fun Byte.udiv(b: Ubyte) = (toUInt() / b.toInt()).toByte()
-infix fun Byte.urem(b: Ubyte) = (toUInt() % b.toInt()).toByte()
-infix fun Byte.ucmp(b: Ubyte) = toUInt().compareTo(b.toInt())
-infix fun Byte.ushr(b: Ubyte) = (toUInt() ushr b.toInt()).toByte()
-
-
-operator fun Byte.plus(b: Ushort) = (this + b.v).toByte()
-operator fun Byte.minus(b: Ushort) = (this - b.v).toByte()
-operator fun Byte.times(b: Ushort) = (this * b.v).toByte()
-infix fun Byte.and(b: Ushort) = this and b.toByte()
-infix fun Byte.or(b: Ushort) = this or b.toByte()
-infix fun Byte.xor(b: Ushort) = this xor b.toByte()
-infix fun Byte.shl(b: Ushort) = (toInt() shl b.toInt()).toByte()
-
-infix fun Byte.udiv(b: Ushort) = (toUInt() / b.toInt()).toByte()
-infix fun Byte.urem(b: Ushort) = (toUInt() % b.toInt()).toByte()
-infix fun Byte.ucmp(b: Ushort) = toUInt().compareTo(b.toInt())
-infix fun Byte.ushr(b: Ushort) = (toUInt() ushr b.toInt()).toByte()
-
-
-operator fun Byte.plus(b: Uint) = (this + b.v).toByte()
-operator fun Byte.minus(b: Uint) = (this - b.v).toByte()
-operator fun Byte.times(b: Uint) = (this * b.v).toByte()
-infix fun Byte.and(b: Uint) = this and b.toByte()
-infix fun Byte.or(b: Uint) = this or b.toByte()
-infix fun Byte.xor(b: Uint) = this xor b.toByte()
-infix fun Byte.shl(b: Uint) = (toInt() shl b.v).toByte()
-
-infix fun Byte.udiv(b: Uint) = (toULong() / b.toLong()).toByte()
-infix fun Byte.urem(b: Uint) = (toULong() % b.toLong()).toByte()
-infix fun Byte.ucmp(b: Uint) = toULong().compareTo(b.toLong())
-infix fun Byte.ushr(b: Uint) = (toUInt() ushr b.toInt()).toByte()
-
-
-operator fun Byte.plus(b: Ulong) = (this + b.v).toByte()
-operator fun Byte.minus(b: Ulong) = (this - b.v).toByte()
-operator fun Byte.times(b: Ulong) = (this * b.v).toByte()
-infix fun Byte.and(b: Ulong) = this and b.toByte()
-infix fun Byte.or(b: Ulong) = this or b.toByte()
-infix fun Byte.xor(b: Ulong) = this xor b.toByte()
-infix fun Byte.shl(b: Ulong) = (toInt() shl b.toInt()).toByte()
-
-infix fun Byte.udiv(b: Ulong) = (toULong() / b.toLong()).toByte()
-infix fun Byte.urem(b: Ulong) = (toULong() % b.toLong()).toByte()
-infix fun Byte.ucmp(b: Ulong) = toULong().compareTo(b.toLong())
-// no Byte ushr Ulong
-
diff --git a/src/main/kotlin/unsigned/Int.kt b/src/main/kotlin/unsigned/Int.kt
deleted file mode 100644
index b557a6e..0000000
--- a/src/main/kotlin/unsigned/Int.kt
+++ /dev/null
@@ -1,122 +0,0 @@
-/**
- * Created by GBarbieri on 30.01.2017.
- */
-
-package unsigned
-
-import java.math.BigInteger
-
-
-fun Int.toUByte() = toByte()
-fun Int.toUShort() = toShort()
-fun Int.toULong() = toLong() and 0xffffffffL
-
-fun Int.toUbyte() = Ubyte(this)
-fun Int.toUshort() = Ushort(this)
-fun Int.toUint() = Uint(this)
-fun Int.toUlong() = Ulong(toULong())
-
-fun Int.toBigInt(): BigInteger = BigInteger.valueOf(toLong())
-fun Int.toUBigInt(): BigInteger = BigInteger.valueOf(toULong())
-
-val Int.ub
-    get() = toUbyte()
-val Int.ui
-    get() = toUint()
-val Int.ul
-    get() = toUlong()
-val Int.us
-    get() = toUshort()
-
-infix fun Int.udiv(b: Byte) = (toULong() / b.toUInt()).toInt()
-infix fun Int.urem(b: Byte) = (toULong() % b.toUInt()).toInt()
-infix fun Int.ucmp(b: Byte) = toULong().compareTo(b.toUInt())
-infix fun Int.ushr(b: Byte) = (toULong() ushr b.toUInt()).toInt()
-
-infix fun Int.udiv(b: Short) = (toULong() / b.toUInt()).toInt()
-infix fun Int.urem(b: Short) = (toULong() % b.toUInt()).toInt()
-infix fun Int.ucmp(b: Short) = toULong().compareTo(b.toUInt())
-infix fun Int.ushr(b: Short) = (toULong() ushr b.toUInt()).toInt()
-
-infix fun Int.udiv(b: Int) = (toULong() / b.toULong()).toInt()
-infix fun Int.urem(b: Int) = (toULong() % b.toULong()).toInt()
-infix fun Int.ucmp(b: Int) = toULong().compareTo(b.toULong())
-// Int.ushr is already offered by the Kotlin lib
-
-infix fun Int.udiv(b: Long) = (toBigInt() / b.toBigInt()).toInt()
-infix fun Int.urem(b: Long) = (toBigInt() % b.toBigInt()).toInt()
-infix fun Int.ucmp(b: Long) = toBigInt().compareTo(b.toBigInt())
-// no Int ushr Long
-
-
-operator fun Int.plus(b: Ubyte) = this + b.v
-operator fun Int.minus(b: Ubyte) = this - b.v
-operator fun Int.times(b: Ubyte) = this * b.v
-infix fun Int.and(b: Ubyte) = this and b.toInt()
-infix fun Int.or(b: Ubyte) = this or b.toInt()
-infix fun Int.xor(b: Ubyte) = this xor b.toInt()
-infix fun Int.shl(b: Ubyte) = this shl b.toInt()
-
-infix fun Int.udiv(b: Ubyte) = (toULong() / b.toLong()).toInt()
-infix fun Int.urem(b: Ubyte) = (toULong() % b.toLong()).toInt()
-infix fun Int.ucmp(b: Ubyte) = toULong().compareTo(b.toLong())
-infix fun Int.ushr(b: Ubyte) = this ushr b.toInt()
-
-
-operator fun Int.plus(b: Ushort) = this + b.v
-operator fun Int.minus(b: Ushort) = this - b.v
-operator fun Int.times(b: Ushort) = this * b.v
-infix fun Int.and(b: Ushort) = this and b.toInt()
-infix fun Int.or(b: Ushort) = this or b.toInt()
-infix fun Int.xor(b: Ushort) = this xor b.toInt()
-infix fun Int.shl(b: Ushort) = this shl b.toInt()
-
-infix fun Int.udiv(b: Ushort) = (toULong() / b.toLong()).toInt()
-infix fun Int.urem(b: Ushort) = (toULong() % b.toLong()).toInt()
-infix fun Int.ucmp(b: Ushort) = toULong().compareTo(b.toLong())
-infix fun Int.ushr(b: Ushort) = (toULong() ushr b.toInt()).toInt()
-
-
-operator fun Int.plus(b: Uint) = this + b.v
-operator fun Int.minus(b: Uint) = this - b.v
-operator fun Int.times(b: Uint) = this * b.v
-infix fun Int.and(b: Uint) = this and b.toInt()
-infix fun Int.or(b: Uint) = this or b.toInt()
-infix fun Int.xor(b: Uint) = this xor b.toInt()
-infix fun Int.shl(b: Uint) = this shl b.v
-
-infix fun Int.udiv(b: Uint) = (toULong() / b.toLong()).toInt()
-infix fun Int.urem(b: Uint) = (toULong() % b.toLong()).toInt()
-infix fun Int.ucmp(b: Uint) = toULong().compareTo(b.toLong())
-infix fun Int.ushr(b: Uint) = (toULong() ushr b.toInt()).toInt()
-
-
-operator fun Int.plus(b: Ulong) = (this + b.v).toInt()
-operator fun Int.minus(b: Ulong) = (this - b.v).toInt()
-operator fun Int.times(b: Ulong) = (this * b.v).toInt()
-infix fun Int.and(b: Ulong) = this and b.toInt()
-infix fun Int.or(b: Ulong) = this or b.toInt()
-infix fun Int.xor(b: Ulong) = this xor b.toInt()
-infix fun Int.shl(b: Ulong) = this shl b.toInt()
-
-infix fun Int.udiv(b: Ulong) = (toULong() / b.toLong()).toInt()
-infix fun Int.urem(b: Ulong) = (toULong() % b.toLong()).toInt()
-infix fun Int.ucmp(b: Ulong) = toULong().compareTo(b.toLong())
-// no Int ushr Ulong
-
-
-// binds jdk unsigned operation
-
-infix fun Int.toUnsignedString(radix: Int): String = Integer.toUnsignedString(this, radix)
-/** no-radix version has a different codepath */
-val Int.toUnsignedString: String
-    get() = Integer.toUnsignedString(this)
-
-fun String.parseUnsignedInt(radix: Int = 10): Int = Integer.parseUnsignedInt(this, radix)
-
-infix fun Int.compareUnsigned(b: Int): Int = Integer.compareUnsigned(this, b)
-
-fun Int.toUnsignedLong(): Long = toLong() and 0xffffffffL
-
-infix fun Int.divideUnsigned(divisor: Int) = Integer.divideUnsigned(this, divisor)
-infix fun Int.remainderUnsigned(divisor: Int) = Integer.remainderUnsigned(this, divisor)
diff --git a/src/main/kotlin/unsigned/Long.kt b/src/main/kotlin/unsigned/Long.kt
deleted file mode 100644
index f9e5ce6..0000000
--- a/src/main/kotlin/unsigned/Long.kt
+++ /dev/null
@@ -1,132 +0,0 @@
-package unsigned
-
-
-import java.math.BigInteger
-
-
-// Created by GBarbieri on 31.01.2017.
-
-fun Long.toUByte() = toByte()
-fun Long.toUShort() = toShort()
-fun Long.toUInt() = toInt()
-
-fun Long.toUbyte() = Ubyte(this)
-fun Long.toUshort() = Ushort(this)
-fun Long.toUint() = Uint(this)
-fun Long.toUlong() = Ulong(this)
-
-fun Long.toBigInt(): BigInteger = BigInteger.valueOf(this)
-fun Long.toUBigInt(): BigInteger = BigInteger(toUnsignedString)
-
-val Long.ub
-    get() = toUbyte()
-val Long.ui
-    get() = toUint()
-val Long.ul
-    get() = toUlong()
-val Long.us
-    get() = toUshort()
-
-infix fun Long.udiv(b: Byte) = (toUBigInt() / b.toUBigInt()).toLong()
-infix fun Long.urem(b: Byte) = (toUBigInt() % b.toUBigInt()).toLong()
-infix fun Long.ucmp(b: Byte) = toUBigInt().compareTo(b.toUBigInt())
-infix fun Long.ushr(b: Byte) = (toUBigInt() ushr b.toUInt()).toLong()
-
-infix fun Long.udiv(b: Short) = (toUBigInt() / b.toUBigInt()).toLong()
-infix fun Long.urem(b: Short) = (toUBigInt() % b.toUBigInt()).toLong()
-infix fun Long.ucmp(b: Short) = toUBigInt().compareTo(b.toUBigInt())
-infix fun Long.ushr(b: Short) = (toUBigInt() ushr b.toUInt()).toLong()
-
-infix fun Long.udiv(b: Int) = (toUBigInt() / b.toUBigInt()).toLong()
-infix fun Long.urem(b: Int) = (toUBigInt() % b.toUBigInt()).toLong()
-infix fun Long.ucmp(b: Int) = toUBigInt().compareTo(b.toUBigInt())
-// Long.ushr(b: Int) offered by Kotlin lib
-
-infix fun Long.udiv(b: Long) = (toUBigInt() / b.toUBigInt()).toLong()
-infix fun Long.urem(b: Long) = (toUBigInt() % b.toUBigInt()).toLong()
-infix fun Long.ucmp(b: Long) = toUBigInt().compareTo(b.toUBigInt())
-// no Long ushr Long
-
-
-operator fun Long.plus(b: Ubyte) = this + b.v
-operator fun Long.minus(b: Ubyte) = this - b.v
-operator fun Long.times(b: Ubyte) = this * b.v
-infix fun Long.and(b: Ubyte) = this and b.toLong()
-infix fun Long.or(b: Ubyte) = this or b.toLong()
-infix fun Long.xor(b: Ubyte) = this xor b.toLong()
-infix fun Long.shl(b: Ubyte) = this shl b.toInt()
-
-infix fun Long.udiv(b: Ubyte) = (toUBigInt() / b.toBigInt()).toLong()
-infix fun Long.urem(b: Ubyte) = (toUBigInt() % b.toBigInt()).toLong()
-infix fun Long.ucmp(b: Ubyte) = toUBigInt().compareTo(b.toBigInt())
-infix fun Long.ushr(b: Ubyte) = this ushr b.toInt()
-
-
-operator fun Long.plus(b: Ushort) = this + b.v
-operator fun Long.minus(b: Ushort) = this - b.v
-operator fun Long.times(b: Ushort) = this * b.v
-infix fun Long.and(b: Ushort) = this and b.toLong()
-infix fun Long.or(b: Ushort) = this or b.toLong()
-infix fun Long.xor(b: Ushort) = this xor b.toLong()
-infix fun Long.shl(b: Ushort) = this shl b.toInt()
-
-infix fun Long.udiv(b: Ushort) = (toUBigInt() / b.toBigInt()).toLong()
-infix fun Long.urem(b: Ushort) = (toUBigInt() % b.toBigInt()).toLong()
-infix fun Long.ucmp(b: Ushort) = toUBigInt().compareTo(b.toBigInt())
-infix fun Long.ushr(b: Ushort) = (toUBigInt() ushr b.toInt()).toLong()
-
-
-operator fun Long.plus(b: Uint) = this + b.v
-operator fun Long.minus(b: Uint) = this - b.v
-operator fun Long.times(b: Uint) = this * b.v
-infix fun Long.and(b: Uint) = this and b.toLong()
-infix fun Long.or(b: Uint) = this or b.toLong()
-infix fun Long.xor(b: Uint) = this xor b.toLong()
-infix fun Long.shl(b: Uint) = this shl b.v
-
-infix fun Long.udiv(b: Uint) = (toUBigInt() / b.toBigInt()).toLong()
-infix fun Long.urem(b: Uint) = (toUBigInt() % b.toBigInt()).toLong()
-infix fun Long.ucmp(b: Uint) = toUBigInt().compareTo(b.toBigInt())
-infix fun Long.ushr(b: Uint) = (toUBigInt() ushr b.toInt()).toLong()
-
-
-operator fun Long.plus(b: Ulong) = this + b.v
-operator fun Long.minus(b: Ulong) = this - b.v
-operator fun Long.times(b: Ulong) = this * b.v
-infix fun Long.and(b: Ulong) = this and b.toLong()
-infix fun Long.or(b: Ulong) = this or b.toLong()
-infix fun Long.xor(b: Ulong) = this xor b.toLong()
-infix fun Long.shl(b: Ulong) = this shl b.toInt()
-
-infix fun Long.udiv(b: Ulong) = (toUBigInt() / b.toBigInt()).toLong()
-infix fun Long.urem(b: Ulong) = (toUBigInt() % b.toBigInt()).toLong()
-infix fun Long.ucmp(b: Ulong) = toUBigInt().compareTo(b.toBigInt())
-// no Int ushr Ulong
-
-
-infix fun Long.toUnsignedString(radix: Int): String = java.lang.Long.toUnsignedString(this, radix)
-
-fun Long.toUnsignedBigInteger(): BigInteger = when {
-    this >= 0L -> BigInteger.valueOf(this)
-    else -> {
-        val upper = ushr(32).toInt()
-        val lower = toInt()
-
-        // return (upper << 32) + lower
-        BigInteger.valueOf(upper.toLong() and 0xffffffffL).shiftLeft(32) + BigInteger.valueOf(lower.toLong() and 0xffffffffL)
-    }
-}
-
-/** no-radix version has a different codepath */
-val Long.toUnsignedString: String
-    get() = java.lang.Long.toUnsignedString(this)
-
-fun String.parseUnsignedLong(radix: Int = 10): Long = java.lang.Long.parseUnsignedLong(this, radix)
-
-infix fun Long.compareUnsigned(b: Long): Int = java.lang.Long.compareUnsigned(this, b)
-
-infix fun Long.divideUnsigned(divisor: Long) = java.lang.Long.divideUnsigned(this, divisor)
-infix fun Long.remainderUnsigned(divisor: Long) = java.lang.Long.remainderUnsigned(this, divisor)
-
-
-
diff --git a/src/main/kotlin/unsigned/Short.kt b/src/main/kotlin/unsigned/Short.kt
deleted file mode 100644
index b3dacaa..0000000
--- a/src/main/kotlin/unsigned/Short.kt
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * Created by GBarbieri on 03.02.2017.
- */
-
-package unsigned
-
-import java.math.BigInteger
-import kotlin.experimental.and
-import kotlin.experimental.or
-import kotlin.experimental.xor
-
-
-fun Short.toUByte() = toByte()
-fun Short.toUInt() = toInt() and 0xffff
-fun Short.toULong() = toUInt().toLong()
-
-fun Short.toUbyte() = Ubyte(this)
-fun Short.toUshort() = Ushort(this)
-fun Short.toUint() = Uint(toUInt())
-fun Short.toUlong() = Ulong(toUInt())
-
-fun Short.toBigInt(): BigInteger = BigInteger.valueOf(toLong())
-fun Short.toUBigInt(): BigInteger = BigInteger.valueOf(toULong())
-
-val Short.ub
-    get() = toUbyte()
-val Short.ui
-    get() = toUint()
-val Short.ul
-    get() = toUlong()
-val Short.us
-    get() = toUshort()
-
-infix fun Short.udiv(b: Byte) = (toUInt() / b.toUInt()).toShort()
-infix fun Short.urem(b: Byte) = (toUInt() % b.toUInt()).toShort()
-infix fun Short.ucmp(b: Byte) = toUInt().compareTo(b.toUInt())
-infix fun Short.ushr(b: Byte) = (toUInt() ushr b.toUInt()).toShort()
-
-infix fun Short.udiv(b: Short) = (toUInt() / b.toUInt()).toShort()
-infix fun Short.urem(b: Short) = (toUInt() % b.toUInt()).toShort()
-infix fun Short.ucmp(b: Short) = toUInt().compareTo(b.toUInt())
-infix fun Short.ushr(b: Short) = (toUInt() ushr b.toUInt()).toShort()
-
-infix fun Short.udiv(b: Int) = (toULong() / b.toULong()).toShort()
-infix fun Short.urem(b: Int) = (toULong() % b.toULong()).toShort()
-infix fun Short.ucmp(b: Int) = toULong().compareTo(b.toULong())
-infix fun Short.ushr(b: Int) = (toUInt() ushr b).toShort()
-
-infix fun Short.udiv(b: Long) = (toBigInt() / b.toBigInt()).toShort()
-infix fun Short.urem(b: Long) = (toBigInt() % b.toBigInt()).toShort()
-infix fun Short.ucmp(b: Long) = toBigInt().compareTo(b.toBigInt())
-// no Short ushr Long
-
-
-operator fun Short.plus(b: Ubyte) = (this + b.v).toShort()
-operator fun Short.minus(b: Ubyte) = (this - b.v).toShort()
-operator fun Short.times(b: Ubyte) = (this * b.v).toShort()
-infix fun Short.and(b: Ubyte) = this and b.toShort()
-infix fun Short.or(b: Ubyte) = this or b.toShort()
-infix fun Short.xor(b: Ubyte) = this xor b.toShort()
-infix fun Short.shl(b: Ubyte) = (toInt() shl b.toInt()).toShort()
-
-infix fun Short.udiv(b: Ubyte) = (toUInt() / b.toInt()).toShort()
-infix fun Short.urem(b: Ubyte) = (toUInt() % b.toInt()).toShort()
-infix fun Short.ucmp(b: Ubyte) = toUInt().compareTo(b.toInt())
-infix fun Short.ushr(b: Ubyte) = (toUInt() ushr b.toInt()).toShort()
-
-
-operator fun Short.plus(b: Ushort) = (this + b.v).toShort()
-operator fun Short.minus(b: Ushort) = (this - b.v).toShort()
-operator fun Short.times(b: Ushort) = (this * b.v).toShort()
-infix fun Short.and(b: Ushort) = this and b.v
-infix fun Short.or(b: Ushort) = this or b.v
-infix fun Short.xor(b: Ushort) = this xor b.v
-infix fun Short.shl(b: Ushort) = (toInt() shl b.toInt()).toShort()
-
-infix fun Short.udiv(b: Ushort) = (toUInt() / b.toInt()).toShort()
-infix fun Short.urem(b: Ushort) = (toUInt() % b.toInt()).toShort()
-infix fun Short.ucmp(b: Ushort) = toUInt().compareTo(b.toInt())
-infix fun Short.ushr(b: Ushort) = (toUInt() ushr b.toInt()).toShort()
-
-
-operator fun Short.plus(b: Uint) = (this + b.v).toShort()
-operator fun Short.minus(b: Uint) = (this - b.v).toShort()
-operator fun Short.times(b: Uint) = (this * b.v).toShort()
-infix fun Short.and(b: Uint) = this and b.toShort()
-infix fun Short.or(b: Uint) = this or b.toShort()
-infix fun Short.xor(b: Uint) = this xor b.toShort()
-infix fun Short.shl(b: Uint) = (toInt() shl b.v).toShort()
-
-infix fun Short.udiv(b: Uint) = (toULong() / b.toLong()).toShort()
-infix fun Short.urem(b: Uint) = (toULong() % b.toLong()).toShort()
-infix fun Short.ucmp(b: Uint) = toULong().compareTo(b.toLong())
-infix fun Short.ushr(b: Uint) = (toUInt() ushr b.toInt()).toShort()
-
-
-operator fun Short.plus(b: Ulong) = (this + b.v).toShort()
-operator fun Short.minus(b: Ulong) = (this - b.v).toShort()
-operator fun Short.times(b: Ulong) = (this * b.v).toShort()
-infix fun Short.and(b: Ulong) = this and b.toShort()
-infix fun Short.or(b: Ulong) = this or b.toShort()
-infix fun Short.xor(b: Ulong) = this xor b.toShort()
-infix fun Short.shl(b: Ulong) = (toInt() shl b.toInt()).toShort()
-
-infix fun Short.udiv(b: Ulong) = (toULong() / b.toLong()).toShort()
-infix fun Short.urem(b: Ulong) = (toULong() % b.toLong()).toShort()
-infix fun Short.ucmp(b: Ulong) = toULong().compareTo(b.toLong())
-// no Short ushr Ulong
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/Ubyte.kt b/src/main/kotlin/unsigned/Ubyte.kt
deleted file mode 100644
index a7f4caa..0000000
--- a/src/main/kotlin/unsigned/Ubyte.kt
+++ /dev/null
@@ -1,106 +0,0 @@
-package unsigned
-
-import java.math.BigInteger
-import kotlin.experimental.and
-import kotlin.experimental.inv
-
-/**
- * Created by GBarbieri on 20.03.2017.
- */
-
-class Ubyte(var v: Byte) : Number(), Comparable<Ubyte> {
-
-    companion object {
-
-        /** A constant holding the minimum value an <code>unsigned byte</code> can have, 0. */
-        const val MIN_VALUE: Int = 0
-        /** A constant holding the maximum value an <code>unsigned byte</code> can have, 2<sup>8</sup>-1.   */
-        const val MAX_VALUE: Int = 0xff
-
-        /** A constant holding the minimum value an <code>unsigned byte</code> can have, 0. */
-        val MIN = Ubyte(0)
-        /** A constant holding the maximum value an <code>unsigned byte</code> can have, 2<sup>8</sup>-1.   */
-        val MAX = Ubyte(0xff)
-
-        fun checkSigned(v: Number) = v.toInt() in MIN_VALUE..MAX_VALUE
-    }
-
-    constructor(number: Number) : this(number.toByte())
-    @JvmOverloads
-    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base).toByte())
-
-    override fun toByte() = v
-    override fun toShort() = v.toUInt().toShort()
-    override fun toInt() = v.toUInt()
-    override fun toLong() = v.toULong()
-
-    fun toBigInt(): BigInteger = BigInteger.valueOf(toLong())
-
-    override fun toDouble() = toInt().toDouble()
-    override fun toFloat() = toInt().toFloat()
-
-    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
-    override fun toChar() = toInt().toChar()
-
-    fun toUbyte() = this
-    fun toUshort() = Ushort(toInt())
-    fun toUint() = Uint(toInt())
-    fun toUlong() = Ulong(toInt())
-
-    operator fun inc() = Ubyte(v + 1)
-    operator fun dec() = Ubyte(v - 1)
-
-    infix operator fun plus(b: Ubyte) = Ubyte(toInt() + b.toInt())
-    infix operator fun plus(b: Byte) = Ubyte(toInt() + b.toUInt())
-    infix operator fun plus(b: Int) = Ubyte(toInt() + b)
-
-    infix operator fun minus(b: Ubyte) = Ubyte(toInt() - b.toInt())
-    infix operator fun minus(b: Byte) = Ubyte(toInt() - b.toUInt())
-    infix operator fun minus(b: Int) = Ubyte(toInt() - b)
-
-    infix operator fun times(b: Ubyte) = Ubyte(toInt() * b.toInt())
-    infix operator fun times(b: Byte) = Ubyte(toInt() * b.toUInt())
-    infix operator fun times(b: Int) = Ubyte(toInt() * b)
-
-    infix operator fun div(b: Ubyte) = Ubyte(toInt() / b.toInt())
-    infix operator fun div(b: Byte) = Ubyte(toInt() / b.toUInt())
-    infix operator fun div(b: Int) = Ubyte(toInt() udiv b)
-
-    infix operator fun rem(b: Ubyte) = Ubyte(toInt() % b.toInt())
-    infix operator fun rem(b: Byte) = Ubyte(toInt() % b.toUInt())
-    infix operator fun rem(b: Int) = Ubyte(toInt() urem b)
-
-    // TODO add counterparts with res
-
-    infix fun and(b: Ubyte) = Ubyte(v and b.v)
-    infix fun and(b: Byte) = Ubyte(v and b)
-    infix fun and(b: Int) = Ubyte(toInt() and b)
-
-    infix fun or(b: Ubyte) = Ubyte(toInt() or b.toInt())
-    infix fun or(b: Byte) = Ubyte(toInt() or b.toUInt())
-    infix fun or(b: Int) = Ubyte(toInt() or b)
-
-    infix fun xor(b: Ubyte) = Ubyte(toInt() xor b.toInt())
-    infix fun xor(b: Byte) = Ubyte(toInt() xor b.toUInt())
-    infix fun xor(b: Int) = Ubyte(toInt() xor b)
-
-    infix fun shl(b: Ubyte) = Ubyte(toInt() shl b.toInt())
-    infix fun shl(b: Byte) = Ubyte(toInt() shl b.toUInt())
-    infix fun shl(b: Int) = Ubyte(toInt() shl b)
-
-    infix fun shr(b: Ubyte) = Ubyte(toInt() ushr b.toInt())
-    infix fun shr(b: Byte) = Ubyte(toInt() ushr b.toUInt())
-    infix fun shr(b: Int) = Ubyte(toInt() ushr b)
-
-    fun inv() = Ubyte(v.inv())
-
-    override operator fun compareTo(other: Ubyte) = toInt() compareUnsigned other.toInt()
-    operator fun compareTo(other: Byte) = toInt() compareUnsigned other.toUInt()
-    operator fun compareTo(other: Int) = toInt() compareUnsigned other
-
-    override fun equals(other: Any?) = other is Ubyte && v == other.v
-    override fun hashCode(): Int = v.hashCode()
-    override fun toString() = toInt().toString()
-    fun toString(radix: Int) = toInt().toString(radix)
-    fun toString(format: String) = format.format(toInt())
-}
diff --git a/src/main/kotlin/unsigned/Uint.kt b/src/main/kotlin/unsigned/Uint.kt
deleted file mode 100644
index f751cc8..0000000
--- a/src/main/kotlin/unsigned/Uint.kt
+++ /dev/null
@@ -1,91 +0,0 @@
-package unsigned
-
-import java.math.BigInteger
-
-/**
- * Created by GBarbieri on 20.03.2017.
- */
-
-data class Uint(var v: Int = 0) : Number(), Comparable<Uint> {
-
-    companion object {
-
-        /** A constant holding the minimum value an <code>unsigned int</code> can have, 0.  */
-        const val MIN_VALUE: Long = 0L
-
-        /** A constant holding the maximum value an <code>unsigned int</code> can have, 2<sup>32</sup>-1.   */
-        const val MAX_VALUE: Long = 0xffffffffL
-
-        /** A constant holding the minimum value an <code>unsigned int</code> can have, 0.  */
-        val MIN = Uint(0)
-
-        /** A constant holding the maximum value an <code>unsigned int</code> can have, 2<sup>32</sup>-1.   */
-        val MAX = Uint(-1)
-
-        fun checkSigned(v: Number) = v.toLong() in MIN_VALUE..MAX_VALUE
-    }
-
-
-    constructor(number: Number) : this(number.toInt())
-    @JvmOverloads
-    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base))
-
-    override fun toByte() = v.toByte()
-    override fun toShort() = v.toShort()
-    override fun toInt() = v
-    override fun toLong() = v.toULong()
-
-    fun toBigInt(): BigInteger = BigInteger.valueOf(toLong())
-
-    override fun toDouble() = toLong().toDouble()
-    override fun toFloat() = toLong().toFloat()
-
-    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
-    override fun toChar() = v.toChar()
-
-    operator fun inc() = Uint(v + 1)
-    operator fun dec() = Uint(v - 1)
-
-    infix operator fun plus(b: Uint) = Uint(v + b.v)
-    infix operator fun plus(b: Int) = Uint(v + b)
-
-    infix operator fun minus(b: Uint) = Uint(v - b.v)
-    infix operator fun minus(b: Int) = Uint(v - b)
-
-    infix operator fun times(b: Uint) = Uint(v * b.v)
-    infix operator fun times(b: Int) = Uint(v * b)
-
-    infix operator fun div(b: Uint) = Uint(v udiv b.toInt())
-    infix operator fun div(b: Int) = Uint(v udiv b)
-
-    infix operator fun rem(b: Uint) = Uint(v urem b.toInt())
-    infix operator fun rem(b: Int) = Uint(v urem b)
-
-    infix fun and(b: Uint) = Uint(v and b.toInt())
-    infix fun and(b: Int) = Uint(v and b)
-
-    infix fun or(b: Uint) = Uint(v or b.toInt())
-    infix fun or(b: Int) = Uint(v or b)
-
-    infix fun xor(b: Uint) = Uint(v xor b.toInt())
-    infix fun xor(b: Int) = Uint(v xor b)
-
-    infix fun shl(b: Uint) = Uint(v shl b.toInt())
-    infix fun shl(b: Int) = Uint(v shl b)
-
-    infix fun shr(b: Uint) = Uint(v ushr b.toInt())
-    infix fun shr(b: Int) = Uint(v ushr b)
-
-    fun inv() = Uint(v.inv())
-
-    override operator fun compareTo(other: Uint) = v compareUnsigned other.toInt()
-    operator fun compareTo(other: Int) = v compareUnsigned other
-
-    override fun equals(other: Any?) = other is Uint && v == other.v
-    override fun hashCode(): Int = v.hashCode()
-    override fun toString() = toLong().toString()
-    fun toString(radix: Int) = toLong().toString(radix)
-    fun toString(format: String) = format.format(toLong())
-
-    // TODO long?
-}
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/Ulong.kt b/src/main/kotlin/unsigned/Ulong.kt
deleted file mode 100644
index 257a9af..0000000
--- a/src/main/kotlin/unsigned/Ulong.kt
+++ /dev/null
@@ -1,107 +0,0 @@
-package unsigned
-
-import java.math.BigInteger
-
-/**
- * Created by GBarbieri on 20.03.2017.
- */
-
-data class Ulong(var v: Long = 0) : Number(), Comparable<Ulong> {
-
-    companion object {
-
-        /** A constant holding the minimum value an <code>unsigned long</code> can have, 0. */
-        val MIN_VALUE: BigInteger = BigInteger.ZERO
-
-        /** A constant holding the maximum value an <code>unsigned long</code> can have, 2<sup>64</sup>-1.  */
-        val MAX_VALUE = BigInteger("18446744073709551615")
-
-        /** A constant holding the minimum value an <code>unsigned long</code> can have, 0. */
-        val MIN = Ulong(0L)
-
-        /** A constant holding the maximum value an <code>unsigned long</code> can have, 2<sup>64</sup>-1.  */
-        val MAX = Ulong(-1L)
-
-        fun checkSigned(v: Number) = BigInteger.valueOf(v.toLong()) in MIN_VALUE..MAX_VALUE
-    }
-
-    constructor(number: Number) : this(number.toLong())
-    constructor(string: String, base: Int = 10) : this(string.filter { it != '_' && it != '\'' }.parseUnsignedLong(base))
-
-    override fun toByte() = v.toByte()
-    override fun toShort() = v.toShort()
-    override fun toInt() = v.toInt()
-    override fun toLong() = v
-
-    fun toBigInt(): BigInteger = BigInteger(v.toUnsignedString)
-
-    override fun toDouble() = toBigInt().toDouble()
-    override fun toFloat() = toBigInt().toFloat()
-
-    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
-    override fun toChar() = v.toInt().toChar()
-
-    operator fun inc() = Ulong(v + 1)
-    operator fun dec() = Ulong(v - 1)
-
-    infix operator fun plus(b: Ulong) = Ulong(v + b.v)
-    infix operator fun plus(b: Long) = Ulong(v + b)
-
-    infix operator fun minus(b: Ulong) = Ulong(v - b.v)
-    infix operator fun minus(b: Long) = Ulong(v - b)
-
-    infix operator fun times(b: Ulong) = Ulong(v * b.v)
-    infix operator fun times(b: Long) = Ulong(v * b)
-
-    infix operator fun div(b: Ulong) = Ulong(v divideUnsigned b.toLong())
-    infix operator fun div(b: Long) = Ulong(v divideUnsigned b)
-
-    infix operator fun rem(b: Ulong) = Ulong(v remainderUnsigned b.toLong())
-    infix operator fun rem(b: Long) = Ulong(v remainderUnsigned b)
-
-    infix fun and(b: Ulong) = Ulong(v and b.toLong())
-    infix fun and(b: Long) = Ulong(v and b)
-
-    infix fun or(b: Ulong) = Ulong(v or b.toLong())
-    infix fun or(b: Long) = Ulong(v or b)
-
-    infix fun xor(b: Ulong) = Ulong(v xor b.toLong())
-    infix fun xor(b: Long) = Ulong(v xor b)
-
-    infix fun shl(b: Int) = Ulong(v shl b)
-
-    infix fun shr(b: Int) = Ulong(v ushr b)
-
-    fun inv() = Ulong(v.inv())
-
-    override operator fun compareTo(other: Ulong) = v compareUnsigned other.toLong()
-    operator fun compareTo(other: Long) = v compareUnsigned other
-
-    // TODO others
-
-    override fun equals(other: Any?) = other is Ulong && v == other.v
-    override fun hashCode(): Int = v.hashCode()
-    override fun toString() = toBigInt().toString()
-    fun toString(radix: Int) = toBigInt().toString(radix)
-    fun toString(format: String) = format.format(toBigInt())
-
-    operator fun rangeTo(b: Ulong) = UlongRange(this, b)
-
-    class UlongRange(override val start: Ulong, override val endInclusive: Ulong) : ClosedRange<Ulong>, Iterable<Ulong> {
-
-        override fun iterator(): Iterator<Ulong> = UlongIterator(this)
-
-        override fun contains(value: Ulong): Boolean = value in start..endInclusive
-    }
-
-    class UlongIterator(val ulongRange: UlongRange) : Iterator<Ulong> {
-        var current = ulongRange.start
-        override fun next(): Ulong {
-            val result = current
-            current++
-            return result
-        }
-
-        override fun hasNext() = current <= ulongRange.endInclusive
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/Ushort.kt b/src/main/kotlin/unsigned/Ushort.kt
deleted file mode 100644
index f1afc6d..0000000
--- a/src/main/kotlin/unsigned/Ushort.kt
+++ /dev/null
@@ -1,104 +0,0 @@
-package unsigned
-
-import java.math.BigInteger
-import kotlin.experimental.and
-import kotlin.experimental.inv
-import kotlin.experimental.or
-import kotlin.experimental.xor
-
-/**
- * Created by GBarbieri on 20.03.2017.
- */
-
-data class Ushort(var v: Short = 0) : Number(), Comparable<Ushort> {
-
-    companion object {
-
-        /** A constant holding the minimum value an <code>unsigned short</code> can have, 0.    */
-        const val MIN_VALUE: Int = 0
-
-        /** A constant holding the maximum value an <code>unsigned short</code> can have, 2<sup>16</sup>-1. */
-        const val MAX_VALUE: Int = 0xffff
-
-        /** A constant holding the minimum value an <code>unsigned short</code> can have, 0.    */
-        val MIN = Ushort(0)
-
-        /** A constant holding the maximum value an <code>unsigned short</code> can have, 2<sup>16</sup>-1. */
-        val MAX = Ushort(0xffff)
-
-        fun checkSigned(v: Number) = v.toInt() in MIN_VALUE..MAX_VALUE
-    }
-
-    constructor(number: Number) : this(number.toShort())
-    @JvmOverloads
-    constructor(string: String, base: Int = 10) :
-            this(string.filter { it != '_' && it != '\'' }.parseUnsignedInt(base).toShort())
-
-    override fun toByte() = v.toByte()
-    override fun toShort() = v
-    override fun toInt() = v.toUInt()
-    override fun toLong() = v.toULong()
-
-    fun toBigInt(): BigInteger = BigInteger.valueOf(toLong())
-
-    override fun toDouble() = toInt().toDouble()
-    override fun toFloat() = toInt().toFloat()
-
-    @Deprecated("Direct conversion to Char is deprecated. Use toInt().toChar() or Char constructor instead.\nIf you override toChar() function in your Number inheritor, it's recommended to gradually deprecate the overriding function and then remove it.\nSee https://youtrack.jetbrains.com/issue/KT-46465 for details about the migration", replaceWith = ReplaceWith("this.toInt().toChar()"))
-    override fun toChar() = v.toInt().toChar()
-
-    operator fun inc() = Ushort(v + 1)
-    operator fun dec() = Ushort(v - 1)
-
-    infix operator fun plus(b: Ushort) = Ushort(toInt() + b.toInt())
-    infix operator fun plus(b: Short) = Ushort(toInt() + b.toUInt())
-    infix operator fun plus(b: Int) = Ushort(toInt() + b)
-
-    infix operator fun minus(b: Ushort) = Ushort(toInt() - b.toInt())
-    infix operator fun minus(b: Short) = Ushort(toInt() - b.toUInt())
-    infix operator fun minus(b: Int) = Ushort(toInt() - b)
-
-    infix operator fun times(b: Ushort) = Ushort(toInt() * b.toInt())
-    infix operator fun times(b: Short) = Ushort(toInt() * b.toUInt())
-    infix operator fun times(b: Int) = Ushort(toInt() * b)
-
-    infix operator fun div(b: Ushort) = Ushort(toInt() / b.toInt())
-    infix operator fun div(b: Short) = Ushort(toInt() / b.toUInt())
-    infix operator fun div(b: Int) = Ushort(toInt() udiv b)
-
-    infix operator fun rem(b: Ushort) = Ushort(toInt() % b.toInt())
-    infix operator fun rem(b: Short) = Ushort(toInt() % b.toUInt())
-    infix operator fun rem(b: Int) = Ushort(toInt() urem b)
-
-    infix fun and(b: Ushort) = Ushort(v and b.v)
-    infix fun and(b: Short) = Ushort(v and b)
-    infix fun and(b: Int) = Ushort(toInt() and b)
-
-    infix fun or(b: Ushort) = Ushort(v or b.v)
-    infix fun or(b: Short) = Ushort(v or b)
-    infix fun or(b: Int) = Ushort(toInt() or b)
-
-    infix fun xor(b: Ushort) = Ushort(v xor b.v)
-    infix fun xor(b: Short) = Ushort(v xor b)
-    infix fun xor(b: Int) = Ushort(toInt() xor b)
-
-    infix fun shl(b: Ushort) = Ushort(toInt() shl b.toInt())
-    infix fun shl(b: Short) = Ushort(toInt() shl b.toUInt())
-    infix fun shl(b: Int) = Ushort(toInt() shl b)
-
-    infix fun shr(b: Ushort) = Ushort(toInt() ushr b.toInt())
-    infix fun shr(b: Short) = Ushort(toInt() ushr b.toUInt())
-    infix fun shr(b: Int) = Ushort(toInt() ushr b)
-
-    fun inv() = Ushort(v.inv())
-
-    override operator fun compareTo(other: Ushort) = toInt() compareUnsigned other.toInt()
-    operator fun compareTo(other: Short) = toInt() compareUnsigned other.toUInt()
-    operator fun compareTo(other: Int) = toInt() compareUnsigned other
-
-    override fun equals(other: Any?) = other is Ushort && v == other.v
-    override fun hashCode(): Int = v.hashCode()
-    override fun toString() = toInt().toString()
-    fun toString(radix: Int) = toInt().toString(radix)
-    fun toString(format: String) = format.format(toInt())
-}
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/arrays.kt b/src/main/kotlin/unsigned/arrays.kt
deleted file mode 100644
index 93d1731..0000000
--- a/src/main/kotlin/unsigned/arrays.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-package unsigned
-
-
-fun UbyteArray(size: Int) = UbyteArray(ByteArray(size))
-fun UbyteArray(size: Int, init: (Int) -> Byte) = UbyteArray(ByteArray(size, init))
-
-@JvmInline
-value class UbyteArray(val data: ByteArray) {
-
-    operator fun get(index: Int) = Ubyte(data[index])
-
-    operator fun set(index: Int, value: Ubyte) {
-        data[index] = value.v
-    }
-}
-
-
-fun UshortArray(size: Int) = UshortArray(ShortArray(size))
-fun UshortArray(size: Int, init: (Int) -> Short) = UshortArray(ShortArray(size, init))
-
-@JvmInline
-value class UshortArray(val data: ShortArray) {
-
-    operator fun get(index: Int) = Ushort(data[index])
-
-    operator fun set(index: Int, value: Ushort) {
-        data[index] = value.v
-    }
-}
-
-
-fun UintArray(size: Int) = UintArray(IntArray(size))
-fun UintArray(size: Int, init: (Int) -> Int) = UintArray(IntArray(size, init))
-
-@JvmInline
-value class UintArray(val data: IntArray) {
-
-    operator fun get(index: Int) = Uint(data[index])
-
-    operator fun set(index: Int, value: Uint) {
-        data[index] = value.v
-    }
-}
-
-fun UlongArray(size: Int) = UlongArray(LongArray(size))
-fun UlongArray(size: Int, init: (Int) -> Long) = UlongArray(LongArray(size, init))
-
-@JvmInline
-value class UlongArray(val data: LongArray) {
-
-    operator fun get(index: Int) = Ulong(data[index])
-
-    operator fun set(index: Int, value: Ulong) {
-        data[index] = value.v
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/unsigned/unsigned.kt b/src/main/kotlin/unsigned/unsigned.kt
deleted file mode 100644
index 23297e7..0000000
--- a/src/main/kotlin/unsigned/unsigned.kt
+++ /dev/null
@@ -1,19 +0,0 @@
-package unsigned
-
-/**
- * Created by GBarbieri on 06.10.2016.
- */
-
-// TODO if == unsigned.Ubyte?
-fun Number.toUbyte() = Ubyte(toByte())
-
-fun Number.toUint() = Uint(this)
-fun Number.toUlong() = Ulong(toLong())
-fun Number.toUshort() = Ushort(toShort())
-
-// TODO char?
-
-fun Char.toUbyte() = Ubyte(code.toByte())
-fun Char.toUint() = Uint(code)
-fun Char.toUlong() = Ulong(code.toLong())
-fun Char.toUshort() = Ushort(code.toShort())
\ No newline at end of file
diff --git a/src/test/kotlin/unsigned/test.kt b/src/test/kotlin/unsigned/test.kt
deleted file mode 100644
index 1824649..0000000
--- a/src/test/kotlin/unsigned/test.kt
+++ /dev/null
@@ -1,93 +0,0 @@
-package unsigned
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.ints.shouldBeLessThan
-import io.kotest.matchers.shouldBe
-import java.math.BigInteger
-
-/**
- * Created by elect on 15/10/16.
- */
-
-val Int.b
-    get() = toByte()
-val Int.s
-    get() = toShort()
-val Long.b
-    get() = toByte()
-val Long.s
-    get() = toShort()
-val Long.i
-    get() = toInt()
-val BigInteger.L
-    get() = toLong()
-
-
-/**
- * BUG, 0xffffffffffffffff is outside Long range
- * https://youtrack.jetbrains.com/issue/KT-4749
- */
-val String.hL: Long
-    get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' }, 16)
-
-val String.L: Long
-    get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' })
-
-val String.bL: Long
-    get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' }, 2)
-
-
-class Unsigned : StringSpec() {
-
-    init {
-
-        "primitive" {
-
-            250.b udiv 50.b shouldBe 5.b
-            250.b urem 200.b shouldBe 50.b
-            250.b ucmp 251.b shouldBeLessThan 1
-            250.b ucmp 250.b shouldBe 0
-            0b1010_1010.b ushr 4 shouldBe 0b1010.b
-
-            65500.s udiv 500.s shouldBe 131.s
-            65500.s urem 65000.s shouldBe 500.s
-            65500.s ucmp 65501.s shouldBeLessThan 1
-            65500.s ucmp 65500.s shouldBe 0
-            0b0100_1100_0011_1101.s ushr 8 shouldBe 0b100_1100.s
-
-            4_000_000_000.i udiv 2 shouldBe 2_000_000_000
-            2_750_000_000.i urem 2_000_000_000 shouldBe 750_000_000
-            4_000_000_000.i ucmp 4_000_000_001.i shouldBeLessThan 1
-            4_000_000_000.i ucmp 4_000_000_000.i shouldBe 0
-
-            "18_000_000_000_000_000_000".L udiv 2L shouldBe "9'000'000'000'000'000'000".L
-            "17'000'000'000'000'000'000".L urem "9'000'000'000'000'000'000".L shouldBe "8'000'000'000'000'000'000".L
-            "18'000'000'000'000'000'000".L ucmp "18'000'000'000'000'000'001".L shouldBeLessThan 1
-            "18'000'000'000'000'000'001".L ucmp "18'000'000'000'000'000'001".L shouldBe 0
-        }
-
-        "string format" {
-
-            Ubyte(0xff).v.toString() shouldBe "-1"
-            Ubyte(0xff).toString() shouldBe "255"
-            Ushort(0xffff).v.toString() shouldBe "-1"
-            Ushort(0xffff).toString() shouldBe "65535"
-            Uint(0xffff_ffff).v.toString() shouldBe "-1"
-            Uint(0xffff_ffff).toString() shouldBe "4294967295"
-            Ulong(Ulong.MAX_VALUE).v.toString() shouldBe "-1"
-            Ulong(Ulong.MAX_VALUE).toString() shouldBe "18446744073709551615"
-
-            Ubyte.MIN.toString(16) shouldBe "0"
-            Ubyte.MAX.toString(16) shouldBe "ff"
-            Ushort.MIN.toString(16) shouldBe "0"
-            Ushort.MAX.toString(16) shouldBe "ffff"
-            Uint.MIN.toString(16) shouldBe "0"
-            Uint.MAX.toString(16) shouldBe "ffffffff"
-            Ulong.MIN.toString(16) shouldBe "0"
-            Ulong.MAX.toString(16) shouldBe "ffffffffffffffff"
-
-            Ubyte.MAX.toString("%08x") shouldBe "000000ff"
-//            (-71777214294589696L).toBinaryString() shouldBe "1111111100000000111111110000000011111111000000001111111100000000"
-        }
-    }
-}
diff --git a/src/test/kotlin/unsigned/ubyte.kt b/src/test/kotlin/unsigned/ubyte.kt
deleted file mode 100644
index 4359db2..0000000
--- a/src/test/kotlin/unsigned/ubyte.kt
+++ /dev/null
@@ -1,138 +0,0 @@
-package unsigned
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.shouldBe
-import java.math.BigInteger
-import kotlin.experimental.inv
-
-class `Ubyte test` : StringSpec() {
-
-    init {
-        "ubyte" {
-
-            Ubyte(0xff).v shouldBe 0xff.b
-            Ubyte(0b11111111.b).v shouldBe 0xff.b
-            Ubyte("255").v shouldBe 0xff.b
-
-            var a = Ubyte(0xff)
-
-            a.toBigInt() shouldBe BigInteger.valueOf(0xff)
-            a.toDouble() shouldBe 0xff.toDouble()
-            a.toFloat() shouldBe 0xff.toFloat()
-            a.toLong() shouldBe 0xff.toLong()
-            a.toInt() shouldBe 0xff
-            a.toInt().toChar() shouldBe 0xff.toChar()
-            a.toShort() shouldBe 0xff.s
-            a.toByte() shouldBe 0xff.b
-
-            a.toUshort() shouldBe Ushort(0xff)
-            a.toUint() shouldBe Uint(0xff)
-            a.toUlong() shouldBe Ulong(0xff)
-
-            var b = Ubyte(1)
-            var c = Ubyte(0)
-
-            a + b shouldBe c
-            a + 1.b shouldBe c
-            a + 1 shouldBe c
-
-            c = Ubyte(0xfe)
-
-            a - b shouldBe c
-            a - 1.b shouldBe c
-            a - 1 shouldBe c
-
-            a = Ubyte(100)
-            b = Ubyte(2)
-            c = Ubyte(200)
-
-            a * b shouldBe c
-            a * 2.b shouldBe c
-            a * 2 shouldBe c
-
-            c / b shouldBe a
-            c / 2.b shouldBe a
-            c / 2 shouldBe a
-
-            b = Ubyte(175)
-            c = Ubyte(75)
-
-            b % a shouldBe c
-            b % 100.b shouldBe c
-            b % 100 shouldBe c
-
-            a = Ubyte(0b1010_1010)
-            b = Ubyte(0b0000_1111)
-            c = Ubyte(0b0000_1010)
-
-            a and b shouldBe c
-            a and 15.b shouldBe c
-            a and 15 shouldBe c
-
-            c = Ubyte(0b1010_1111)
-
-            a or b shouldBe c
-            a or 175.b shouldBe c
-            a or 175 shouldBe c
-
-            c = Ubyte(0b1010_0101)
-
-            a xor b shouldBe c
-            a xor 15.b shouldBe c
-            a xor 15 shouldBe c
-
-            b = Ubyte(4)
-            c = Ubyte(0b1010_0000)
-
-            a shl b shouldBe c
-            a shl 4.b shouldBe c
-            a shl 4 shouldBe c
-
-            c = Ubyte(0b0000_1010)
-
-            a shr b shouldBe c
-            a shr 4.b shouldBe c
-            a shr 4 shouldBe c
-
-            b = Ubyte(0b0101_0101)
-
-            a.inv() shouldBe b
-
-            a = Ubyte(250)
-
-            (a > Ubyte(249)) shouldBe true
-            (a > 249.b) shouldBe true
-            (a > 249) shouldBe true
-            (a >= a) shouldBe true
-            (a >= 250.b) shouldBe true
-            (a >= 250) shouldBe true
-
-            0xff.b + Ubyte(1) shouldBe 0.b
-            0xff.b - Ubyte(1) shouldBe 0xfe.b
-            100.b * Ubyte(2) shouldBe 200.b
-            200.b udiv Ubyte(2) shouldBe 100.b
-            175.b urem Ubyte(100) shouldBe 75.b
-            0b1010_1010.b and Ubyte(0b0000_1111) shouldBe 0b1010.b
-            0b1010_1010.b or Ubyte(0b0000_1111) shouldBe 0b1010_1111.b
-            0b1010_1010.b xor Ubyte(0b0000_1111) shouldBe 0b1010_0101.b
-            0b1010_1010.b shl Ubyte(4) shouldBe 0b1010_0000.b
-            0b1010_1010.b ushr Ubyte(4) shouldBe 0b1010.b
-            0b1010_1010.b.inv() shouldBe 0b0101_0101.b
-            ((200.b ucmp Ubyte(199)) > 0) shouldBe true
-            (200.b ucmp Ubyte(200)) shouldBe 0
-
-            0xff + Ubyte(1) shouldBe 0b1_0000_0000
-            0xff - Ubyte(1) shouldBe 0xfe
-            100 * Ubyte(2) shouldBe 200
-            200 udiv Ubyte(2) shouldBe 100
-            175 urem Ubyte(100) shouldBe 75
-            0b1010_1010 and Ubyte(0b0000_1111) shouldBe 0b1010
-            0b1010_1010 or Ubyte(0b0000_1111) shouldBe 0b1010_1111
-            0b1010_1010 xor Ubyte(0b0000_1111) shouldBe 0b1010_0101
-            0b1010_1010 shl Ubyte(4) shouldBe 0b1010_1010_0000
-            0b1010_1010 ushr Ubyte(4) shouldBe 0b1010
-            ((200.b ucmp Ubyte(199)) > 0) shouldBe true
-            ((200.b ucmp Ubyte(200)) == 0) shouldBe true
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/unsigned/uint.kt b/src/test/kotlin/unsigned/uint.kt
deleted file mode 100644
index 0a34aa7..0000000
--- a/src/test/kotlin/unsigned/uint.kt
+++ /dev/null
@@ -1,131 +0,0 @@
-package unsigned
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.shouldBe
-import java.math.BigInteger
-
-class `Uint test` : StringSpec() {
-
-    init {
-        "uint" {
-
-            /**
-             * BUG, 0xffffffff is interpreted as Long
-             * https://youtrack.jetbrains.com/issue/KT-2780
-             * https://youtrack.jetbrains.com/issue/KT-4749
-             */
-
-            Uint(0xffff_ffff).v shouldBe 0xffff_ffff.i
-            Uint("4294967295").v shouldBe 0xffff_ffff.i
-
-            var a = Uint(0xffff_ffff)
-
-            a.toBigInt() shouldBe BigInteger.valueOf(0xffff_ffff)
-            a.toDouble() shouldBe 0xffff_ffff.toDouble()
-            a.toFloat() shouldBe 0xffff_ffff.toFloat()
-            a.toLong() shouldBe 0xffff_ffff
-            a.toInt() shouldBe 0xffff_ffff.toInt()
-            a.toInt().toChar() shouldBe 0xffff_ffff.toInt().toChar()
-            a.toShort() shouldBe 0xffff_ffff.s
-            a.toByte() shouldBe 0xffff_ffff.b
-
-            a.toUbyte() shouldBe Ubyte(0xffff_ffff)
-            a.toUshort() shouldBe Ushort(0xffff_ffff)
-            a.toUlong() shouldBe Ulong(0xffff_ffff)
-
-            var b = Uint(1)
-            var c = Uint(0)
-
-            a + b shouldBe c
-            a + 1 shouldBe c
-
-            c = Uint(0xffff_fffe)
-
-            a - b shouldBe c
-            a - 1 shouldBe c
-
-            // TODO underscore https://youtrack.jetbrains.com/issue/KT-2964
-
-            a = Uint(2_000_000_000)
-            b = Uint(2)
-            c = Uint(4_000_000_000)
-
-            a * b shouldBe c
-            a * 2 shouldBe c
-
-            c / b shouldBe a
-            c / 2 shouldBe a
-
-            b = Uint(2_750_000_000)
-            c = Uint(750_000_000)
-
-            b % a shouldBe c
-            b % 2_000_000_000 shouldBe c
-
-            a = Uint(0b1010_1010__1010_1010__1010_1010__1010_1010)
-            b = Uint(0b0000_1111__0000_1111__0000_1111__0000_1111)
-            c = Uint(0b0000_1010__0000_1010__0000_1010__0000_1010)
-
-            a and b shouldBe c
-            a and 0b0000_1111__0000_1111__0000_1111__0000_1111 shouldBe c
-
-            c = Uint(0b1010_1111__1010_1111__1010_1111__1010_1111)
-
-            a or b shouldBe c
-            a or 0b1010_1111__1010_1111__1010_1111__1010_1111.i shouldBe c
-
-            c = Uint(0b1010_0101__1010_0101__1010_0101__1010_0101)
-
-            a xor b shouldBe c
-            a xor 0b0000_1111__0000_1111__0000_1111__0000_1111 shouldBe c
-
-            a = Uint(0b0100_1100__0111_0000__1111_0000__0111_1101)
-            b = Uint(16)
-            c = Uint(0b1111_0000__0111_1101__0000_0000__0000_0000)
-
-            a shl b shouldBe c
-            a shl 16 shouldBe c
-
-            c = Uint(0b0000_0000__0000_0000__0100_1100__0111_0000)
-
-            a shr b shouldBe c
-            a shr 16 shouldBe c
-
-            b = Uint(0b1011_0011__1000_1111__0000_1111__1000_0010)
-
-            a.inv() shouldBe b
-
-            a = Uint(2_000_000_000)
-
-            (a > Uint(2_000_000_000 - 1)) shouldBe true
-            (a > (2_000_000_000 - 1)) shouldBe true
-            (a >= a) shouldBe true
-            (a >= 2_000_000_000) shouldBe true
-
-            0xffff_ffff.i + Uint(1) shouldBe 0
-            0xffff_ffff.i - Uint(1) shouldBe 0xffff_fffe.i
-            2_000_000_000 * Uint(2) shouldBe 4_000_000_000.i
-            4_000_000_000.i udiv Uint(2) shouldBe 2_000_000_000
-            3_750_000_000.i urem Uint(1000000000) shouldBe 750_000_000
-
-            val d = 0b0100_1100__0111_0000__1111_0000__0111_1101
-            val e = 0b0101_0101__0101_0101__0101_0101__0101_0101
-            // 0b01001100011100001111000001111101
-            // 0b01010101010101010101010101010101
-            // 0b01000100010100000101000001010101
-            d and Uint(e) shouldBe 0b0100_0100__0101_0000__0101_0000__0101_0101
-            // 0b01001100011100001111000001111101
-            // 0b01010101010101010101010101010101
-            // 0b01011101011101011111010101111101
-            d or Uint(e) shouldBe 0b0101_1101__0111_0101__1111_0101__0111_1101
-            // 0b01001100011100001111000001111101
-            // 0b01010101010101010101010101010101
-            // 0b00011001001001011010010100101000
-            d xor Uint(e) shouldBe 0b0001_1001__0010_0101__1010_0101__0010_1000
-            d shl Uint(16) shouldBe 0b1111_0000__0111_1101__0000_0000__0000_0000.i
-            d ushr Uint(16) shouldBe 0b0000_0000__0000_0000__0100_1100__0111_0000
-            ((d ucmp Uint(d - 1) > 0)) shouldBe true
-            (d ucmp Uint(d)) shouldBe 0
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/unsigned/ulong.kt b/src/test/kotlin/unsigned/ulong.kt
deleted file mode 100644
index a671d4c..0000000
--- a/src/test/kotlin/unsigned/ulong.kt
+++ /dev/null
@@ -1,124 +0,0 @@
-package unsigned
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.ints.shouldBeLessThan
-import io.kotest.matchers.shouldBe
-
-
-class `Ulong test` : StringSpec() {
-
-    init {
-        "ulong" {
-
-            val max = "ffff_ffff__ffff_ffff".hL
-
-            Ulong(Ulong.MAX_VALUE).v shouldBe max
-            Ulong("18446744073709551615").v shouldBe max
-
-            var a = Ulong(Ulong.Companion.MAX_VALUE)
-
-            a.toBigInt() shouldBe max.toUBigInt()
-            a.toDouble() shouldBe max.toUBigInt().toDouble()
-            a.toFloat() shouldBe max.toUBigInt().toFloat()
-            a.toLong() shouldBe max
-            a.toInt() shouldBe max.toInt()
-            a.toInt().toChar() shouldBe max.toInt().toChar()
-            a.toShort() shouldBe max.s
-            a.toByte() shouldBe max.b
-
-            a.toUbyte() shouldBe Ubyte(max)
-            a.toUshort() shouldBe Ushort(max)
-            a.toUint() shouldBe Uint(max)
-
-            var b = Ulong(1)
-            var c = Ulong(0)
-
-            a + b shouldBe c
-            a + 1 shouldBe c
-
-            c = Ulong("ffff_ffff__ffff_fffe".hL)
-
-            a - b shouldBe c
-            a - 1 shouldBe c
-
-            // BUG underscore https://youtrack.jetbrains.com/issue/KT-2964
-
-            a = Ulong("9_000_000_000_000_000_000")
-            b = Ulong(2)
-            c = Ulong("18_000_000_000_000_000_000")
-
-            a * b shouldBe c
-            a * 2 shouldBe c
-
-            c / b shouldBe a
-            c / 2 shouldBe a
-
-            b = Ulong("17_000_000_000_000_000_000")
-            c = Ulong("8_000_000_000_000_000_000")
-
-            b % a shouldBe c
-            b % "9_000_000_000_000_000_000".L shouldBe c
-
-            a = Ulong("1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010", 2)
-            b = Ulong("0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111", 2)
-            c = Ulong("0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010", 2)
-
-            a and b shouldBe c
-            a and "0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111".bL shouldBe c
-
-            // 1010101010101010101010101010101010101010101010101010101010101010
-            // 0000111100001111000011110000111100001111000011110000111100001111
-            // 1010111110101111101011111010111110101111101011111010111110101111
-            c = Ulong("1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111", 2)
-
-            a or b shouldBe c
-            a or "1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111".bL shouldBe c
-
-            c = Ulong("1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101", 2)
-
-            a xor b shouldBe c
-            a xor "0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111".bL shouldBe c
-
-            a = Ulong("0100_1100__0111_0000__1111_0000__0111_1100__0000_1111__1100_0000__0111_1111__0000_0000", 2)
-            b = Ulong(32)
-            c = Ulong("0000_1111__1100_0000__0111_1111__0000_0000__0000_0000__0000_0000__0000_0000__0000_0000", 2)
-
-            a shl b.toInt() shouldBe c
-            a shl 32 shouldBe c
-
-            c = Ulong("0000_0000__0000_0000__0000_0000__0000_0000__0100_1100__0111_0000__1111_0000__0111_1100", 2)
-
-            a shr b.toInt() shouldBe c
-            a shr 32 shouldBe c
-
-            b = Ulong("1011_0011__1000_1111__0000_1111__1000_0011__1111_0000__0011_1111__1000_0000__1111_1111", 2)
-
-            a.inv() shouldBe b
-
-            a = Ulong("18'000'000'000'000'000'000")
-
-            (a > Ulong("17'999'999'999'999'999'999")) shouldBe true
-            (a > "17'999'999'999'999'999'999".L) shouldBe true
-            (a >= a) shouldBe true
-            (a >= "18'000'000'000'000'000'000".L) shouldBe true
-
-            "ffff_ffff__ffff_ffff".hL + Ulong(1) shouldBe 0L
-            "ffff_ffff__ffff_ffff".hL - Ulong(1) shouldBe "ffff_ffff__ffff_fffe".hL
-            "9'000'000'000'000'000'000".L * Ulong(2) shouldBe "18'000'000'000'000'000'000".L
-            "18'000'000'000'000'000'000".L udiv Ulong(2) shouldBe "9'000'000'000'000'000'000".L
-            "17'000'000'000'000'000'000".L urem Ulong("9'000'000'000'000'000'000") shouldBe "8'000'000'000'000'000'000".L
-
-            var d = "1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010".bL
-            val e = "0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111__0000_1111".bL
-
-            d and Ulong(e) shouldBe "0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010__0000_1010".bL
-            d or Ulong(e) shouldBe "1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111__1010_1111".bL
-            d xor Ulong(e) shouldBe "1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101__1010_0101".bL
-            d = "0100_1100__0111_0000__1111_0000__0111_1100__0000_1111__1100_0000__0111_1111__0000_0000".bL
-            d shl Ulong(32).toInt() shouldBe "0000_1111__1100_0000__0111_1111__0000_0000__0000_0000__0000_0000__0000_0000__0000_0000".bL
-            d shr Ulong(32).toInt() shouldBe "0000_0000__0000_0000__0000_0000__0000_0000__0100_1100__0111_0000__1111_0000__0111_1100".bL
-            (d ucmp Ulong("1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1010__1010_1011", 2)) shouldBeLessThan 0
-            (d ucmp Ulong(d)) shouldBe 0
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/unsigned/ushort.kt b/src/test/kotlin/unsigned/ushort.kt
deleted file mode 100644
index 9ebe3bc..0000000
--- a/src/test/kotlin/unsigned/ushort.kt
+++ /dev/null
@@ -1,141 +0,0 @@
-package unsigned
-
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.shouldBe
-import java.math.BigInteger
-import kotlin.experimental.inv
-
-class `Ushort test` : StringSpec() {
-
-    init {
-        "ushort" {
-
-            Ushort(0xffff).v shouldBe 0xffff.s
-            Ushort(0b1111111111111111.s).v shouldBe 0xffff.s
-            Ushort("65535").v shouldBe 0xffff.s
-
-            var a = Ushort(0xffff)
-
-            a.toBigInt() shouldBe BigInteger.valueOf(0xffff)
-            a.toDouble() shouldBe 0xffff.toDouble()
-            a.toFloat() shouldBe 0xffff.toFloat()
-            a.toLong() shouldBe 0xffff.toLong()
-            a.toInt() shouldBe 0xffff
-            a.toInt().toChar() shouldBe 0xffff.toChar()
-            a.toShort() shouldBe 0xffff.s
-            a.toByte() shouldBe 0xffff.b
-
-            a.toUlong() shouldBe Ulong(0xffff)
-            a.toUint() shouldBe Uint(0xffff)
-            a.toUbyte() shouldBe Ubyte(0xffff)
-
-            var b = Ushort(1)
-            var c = Ushort(0)
-
-            assert(a >= b)
-
-            a + b shouldBe c
-            a + 1.s shouldBe c
-            a + 1 shouldBe c
-
-            c = Ushort(0xfffe)
-
-            a - b shouldBe c
-            a - 1.s shouldBe c
-            a - 1 shouldBe c
-
-            a = Ushort(30_000)
-            b = Ushort(2)
-            c = Ushort(60_000)
-
-            a * b shouldBe c
-            a * 2.s shouldBe c
-            a * 2 shouldBe c
-
-            c / b shouldBe a
-            c / 2.s shouldBe a
-            c / 2 shouldBe a
-
-            b = Ushort(50_000)
-            c = Ushort(20_000)
-
-            b % a shouldBe c
-            b % 30000.s shouldBe c
-            b % 30000 shouldBe c
-
-            a = Ushort(0b1010_1010__1010_1010)
-            b = Ushort(0b0000_1111__0000_1111)
-            c = Ushort(0b0000_1010__0000_1010)
-
-            a and b shouldBe c
-            a and 0b0000_1111__0000_1111.s shouldBe c
-            a and 3_855 shouldBe c
-
-            c = Ushort(0b1010111110101111)
-
-            a or b shouldBe c
-            a or 0b1010_1111__1010_1111.s shouldBe c
-            a or 44_975 shouldBe c
-
-            c = Ushort(0b1010_0101__1010_0101)
-
-            a xor b shouldBe c
-            a xor 0b0000_1111__0000_1111.s shouldBe c
-            a xor 3855 shouldBe c
-
-            a = Ushort(0b0100_1100__0011_1101)
-            b = Ushort(8)
-            c = Ushort(0b0011_1101__0000_0000)
-
-            a shl b shouldBe c
-            a shl 8.s shouldBe c
-            a shl 8 shouldBe c
-
-            c = Ushort(0b0000_0000__0100_1100)
-
-            a shr b shouldBe c
-            a shr 8.s shouldBe c
-            a shr 8 shouldBe c
-
-            b = Ushort(0b1011_0011__1100_0010)
-
-            a.inv() shouldBe b
-
-            a = Ushort(65_500)
-
-            (a > Ushort(65_499)) shouldBe true
-            (a > 65499.s) shouldBe true
-            (a > 65499) shouldBe true
-            (a >= a) shouldBe true
-            (a >= 65500.s) shouldBe true
-            (a >= 65500) shouldBe true
-
-            0xffff.s + Ushort(1) shouldBe 0.s
-            0xffff.s - Ushort(1) shouldBe 0xfffe.s
-            30_000.s * Ushort(2) shouldBe 60_000.s
-            60_000.s udiv Ushort(2) shouldBe 30_000.s
-            65_000.s urem Ushort(10_000) shouldBe 5_000.s
-            0b1010_1010__1010_1010.s and Ushort(0b0000_1111__0000_1111) shouldBe 0b0000_1010__0000_1010.s
-            0b1010_1010__1010_1010.s or Ushort(0b0000_1111__0000_1111) shouldBe 0b1010_1111__1010_1111.s
-            0b1010_1010__1010_1010.s xor Ushort(0b0000_1111__0000_1111) shouldBe 0b1010_0101_1010_0101.s
-            0b0100_1100__0011_1101.s shl Ushort(8) shouldBe 0b0011_1101__0000_0000.s
-            0b0100_1100__0011_1101.s ushr Ushort(8) shouldBe 0b0000_0000__0100_1100.s
-            0b0100_1100__0011_1101.s.inv() shouldBe 0b1011_0011__1100_0010.s
-            ((65_500.s ucmp Ushort(65_499)) > 0) shouldBe true
-            (65_500.s ucmp Ushort(65_500)) shouldBe 0
-
-            0xffff + Ushort(1) shouldBe 0b1000_0000__0000_00000
-            0xffff - Ushort(1) shouldBe 0xfffe
-            30_000 * Ushort(2) shouldBe 60_000
-            60_000 udiv Ushort(2) shouldBe 30_000
-            65_000 urem Ushort(10_000) shouldBe 5_000
-            0b1010_1010__1010_1010 and Ushort(0b0000_1111__0000_1111) shouldBe 0b0000_1010__0000_1010
-            0b1010_1010__1010_1010 or Ushort(0b0000_1111__0000_1111) shouldBe 0b1010_1111__1010_1111
-            0b1010_1010__1010_1010 xor Ushort(0b0000_1111__0000_1111) shouldBe 0b1010_0101__1010_0101
-            0b0100_1100__0011_1101 shl Ushort(8) shouldBe 0b0100_1100__0011_1101__0000_0000
-            0b0100_1100__0011_1101 ushr Ushort(8) shouldBe 0b100_1100
-            ((65_500 ucmp Ushort(65_499)) > 0) shouldBe true
-            (65_500 ucmp Ushort(65_500)) shouldBe 0
-        }
-    }
-}
\ No newline at end of file