diff --git a/applications/applications.c b/applications/applications.c
index 515ba33e..86f765c8 100644
--- a/applications/applications.c
+++ b/applications/applications.c
@@ -20,6 +20,7 @@ extern int32_t desktop_srv(void* p);
 extern int32_t accessor_app(void* p);
 extern int32_t archive_app(void* p);
 extern int32_t bad_usb_app(void* p);
+extern int32_t u2f_app(void* p);
 extern int32_t uart_echo_app(void* p);
 extern int32_t blink_test_app(void* p);
 extern int32_t bt_debug_app(void* p);
@@ -154,6 +155,11 @@ const FlipperApplication FLIPPER_APPS[] = {
 #ifdef APP_BAD_USB
     {.app = bad_usb_app, .name = "Bad USB", .stack_size = 2048, .icon = &A_BadUsb_14},
 #endif
+
+#ifdef APP_U2F
+    {.app = u2f_app, .name = "U2F", .stack_size = 2048, .icon = &A_U2F_14},
+#endif
+
 };
 
 const size_t FLIPPER_APPS_COUNT = sizeof(FLIPPER_APPS) / sizeof(FlipperApplication);
diff --git a/applications/applications.mk b/applications/applications.mk
index 35069882..c5843fee 100644
--- a/applications/applications.mk
+++ b/applications/applications.mk
@@ -50,6 +50,7 @@ APP_DISPLAY_TEST = 1
 APP_BLE_HID = 1
 APP_USB_MOUSE = 1
 APP_BAD_USB = 1
+APP_U2F = 1
 APP_UART_ECHO = 1
 endif
 
@@ -165,7 +166,13 @@ APP_BAD_USB ?= 0
 ifeq ($(APP_BAD_USB), 1)
 CFLAGS		+= -DAPP_BAD_USB
 SRV_GUI = 1
-endif 
+endif
+
+APP_U2F ?= 0
+ifeq ($(APP_U2F), 1)
+CFLAGS		+= -DAPP_U2F
+SRV_GUI = 1
+endif
 
 APP_BLE_HID ?=0
 ifeq ($(APP_BLE_HID), 1)
diff --git a/applications/debug_tools/usb_test.c b/applications/debug_tools/usb_test.c
index cacd715a..d613d527 100644
--- a/applications/debug_tools/usb_test.c
+++ b/applications/debug_tools/usb_test.c
@@ -35,7 +35,7 @@ void usb_test_submenu_callback(void* context, uint32_t index) {
     } else if(index == UsbTestSubmenuIndexHid) {
         furi_hal_usb_set_config(&usb_hid);
     } else if(index == UsbTestSubmenuIndexHidU2F) {
-        //furi_hal_usb_set_config(UsbModeU2F);
+        furi_hal_usb_set_config(&usb_hid_u2f);
     }
 }
 
@@ -67,7 +67,7 @@ UsbTestApp* usb_test_app_alloc() {
     submenu_add_item(
         app->submenu, "HID KB+Mouse", UsbTestSubmenuIndexHid, usb_test_submenu_callback, app);
     submenu_add_item(
-        app->submenu, "TODO: HID U2F", UsbTestSubmenuIndexHidU2F, usb_test_submenu_callback, app);
+        app->submenu, "HID U2F", UsbTestSubmenuIndexHidU2F, usb_test_submenu_callback, app);
     view_set_previous_callback(submenu_get_view(app->submenu), usb_test_exit);
     view_dispatcher_add_view(app->view_dispatcher, 0, submenu_get_view(app->submenu));
 
diff --git a/applications/subghz/subghz.c b/applications/subghz/subghz.c
index 23599739..884bd4a3 100644
--- a/applications/subghz/subghz.c
+++ b/applications/subghz/subghz.c
@@ -1,7 +1,4 @@
-/*
-*    Give up hope, everyone who enters here!!!
-*      Оставь надежду, всяк сюда входящий!!!
-*/
+/* Abandon hope, all ye who enter here. */
 
 #include "subghz_i.h"
 #include <lib/toolbox/path.h>
@@ -329,4 +326,4 @@ int32_t subghz_app(void* p) {
     subghz_free(subghz);
 
     return 0;
-}
\ No newline at end of file
+}
diff --git a/applications/u2f/scenes/u2f_scene.c b/applications/u2f/scenes/u2f_scene.c
new file mode 100644
index 00000000..92739fca
--- /dev/null
+++ b/applications/u2f/scenes/u2f_scene.c
@@ -0,0 +1,30 @@
+#include "u2f_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const u2f_scene_on_enter_handlers[])(void*) = {
+#include "u2f_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const u2f_scene_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "u2f_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const u2f_scene_on_exit_handlers[])(void* context) = {
+#include "u2f_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers u2f_scene_handlers = {
+    .on_enter_handlers = u2f_scene_on_enter_handlers,
+    .on_event_handlers = u2f_scene_on_event_handlers,
+    .on_exit_handlers = u2f_scene_on_exit_handlers,
+    .scene_num = U2fSceneNum,
+};
diff --git a/applications/u2f/scenes/u2f_scene.h b/applications/u2f/scenes/u2f_scene.h
new file mode 100644
index 00000000..1a9dcd75
--- /dev/null
+++ b/applications/u2f/scenes/u2f_scene.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) U2fScene##id,
+typedef enum {
+#include "u2f_scene_config.h"
+    U2fSceneNum,
+} U2fScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers u2f_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "u2f_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "u2f_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "u2f_scene_config.h"
+#undef ADD_SCENE
diff --git a/applications/u2f/scenes/u2f_scene_config.h b/applications/u2f/scenes/u2f_scene_config.h
new file mode 100644
index 00000000..636589f2
--- /dev/null
+++ b/applications/u2f/scenes/u2f_scene_config.h
@@ -0,0 +1 @@
+ADD_SCENE(u2f, main, Main)
diff --git a/applications/u2f/scenes/u2f_scene_main.c b/applications/u2f/scenes/u2f_scene_main.c
new file mode 100644
index 00000000..6967a679
--- /dev/null
+++ b/applications/u2f/scenes/u2f_scene_main.c
@@ -0,0 +1,92 @@
+#include "../u2f_app_i.h"
+#include "../views/u2f_view.h"
+#include "furi-hal.h"
+#include "../u2f.h"
+
+#define U2F_EVENT_TIMEOUT 500
+
+static void u2f_scene_main_ok_callback(InputType type, void* context) {
+    furi_assert(context);
+    U2fApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, U2fCustomEventConfirm);
+}
+
+static void u2f_scene_main_event_callback(U2fNotifyEvent evt, void* context) {
+    furi_assert(context);
+    U2fApp* app = context;
+    if(evt == U2fNotifyRegister)
+        view_dispatcher_send_custom_event(app->view_dispatcher, U2fCustomEventRegister);
+    else if(evt == U2fNotifyAuth)
+        view_dispatcher_send_custom_event(app->view_dispatcher, U2fCustomEventAuth);
+    else if(evt == U2fNotifyWink)
+        view_dispatcher_send_custom_event(app->view_dispatcher, U2fCustomEventWink);
+}
+
+static void u2f_scene_main_timer_callback(void* context) {
+    furi_assert(context);
+    U2fApp* app = context;
+    view_dispatcher_send_custom_event(app->view_dispatcher, U2fCustomEventTimeout);
+}
+
+bool u2f_scene_main_on_event(void* context, SceneManagerEvent event) {
+    furi_assert(context);
+    U2fApp* app = context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if((event.event == U2fCustomEventRegister) || (event.event == U2fCustomEventAuth)) {
+            osTimerStart(app->timer, U2F_EVENT_TIMEOUT);
+            if(app->event_cur == U2fCustomEventNone) {
+                app->event_cur = event.event;
+                if(event.event == U2fCustomEventRegister)
+                    u2f_view_set_state(app->u2f_view, U2fMsgRegister);
+                else if(event.event == U2fCustomEventAuth)
+                    u2f_view_set_state(app->u2f_view, U2fMsgAuth);
+                notification_message(app->notifications, &sequence_success);
+            }
+            notification_message(app->notifications, &sequence_blink_blue_10);
+        } else if(event.event == U2fCustomEventWink) {
+            notification_message(app->notifications, &sequence_blink_green_10);
+        } else if(event.event == U2fCustomEventTimeout) {
+            app->event_cur = U2fCustomEventNone;
+            u2f_view_set_state(app->u2f_view, U2fMsgNone);
+        } else if(event.event == U2fCustomEventConfirm) {
+            if(app->event_cur != U2fCustomEventNone) {
+                u2f_confirm_user_present(app->u2f_instance);
+            }
+        }
+
+        consumed = true;
+    } else if(event.type == SceneManagerEventTypeTick) {
+    }
+    return consumed;
+}
+
+void u2f_scene_main_on_enter(void* context) {
+    U2fApp* app = context;
+
+    app->timer = osTimerNew(u2f_scene_main_timer_callback, osTimerOnce, app, NULL);
+
+    app->u2f_instance = u2f_alloc();
+    app->u2f_ready = u2f_init(app->u2f_instance);
+    if(app->u2f_ready == true) {
+        u2f_set_event_callback(app->u2f_instance, u2f_scene_main_event_callback, app);
+        app->u2f_hid = u2f_hid_start(app->u2f_instance);
+        u2f_view_set_ok_callback(app->u2f_view, u2f_scene_main_ok_callback, app);
+    } else {
+        u2f_free(app->u2f_instance);
+        u2f_view_set_state(app->u2f_view, U2fMsgError);
+    }
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, U2fAppViewMain);
+}
+
+void u2f_scene_main_on_exit(void* context) {
+    U2fApp* app = context;
+    osTimerStop(app->timer);
+    osTimerDelete(app->timer);
+    if(app->u2f_ready == true) {
+        u2f_hid_stop(app->u2f_hid);
+        u2f_free(app->u2f_instance);
+    }
+}
diff --git a/applications/u2f/u2f.c b/applications/u2f/u2f.c
new file mode 100644
index 00000000..04c8e1df
--- /dev/null
+++ b/applications/u2f/u2f.c
@@ -0,0 +1,332 @@
+#include <furi.h>
+#include "u2f.h"
+#include "u2f_hid.h"
+#include "u2f_data.h"
+#include <furi-hal.h>
+#include <furi-hal-random.h>
+
+#include "toolbox/sha256.h"
+#include "toolbox/hmac_sha256.h"
+#include "micro-ecc/uECC.h"
+
+#define TAG "U2F"
+#define WORKER_TAG TAG "Worker"
+
+#define U2F_CMD_REGISTER 0x01
+#define U2F_CMD_AUTHENTICATE 0x02
+#define U2F_CMD_VERSION 0x03
+
+typedef enum {
+    U2fCheckOnly = 0x07, // "check-only" - only check key handle, don't send auth response
+    U2fEnforce =
+        0x03, // "enforce-user-presence-and-sign" - send auth response only if user is present
+    U2fDontEnforce =
+        0x08, // "dont-enforce-user-presence-and-sign" - send auth response even if user is missing
+} U2fAuthMode;
+
+typedef struct {
+    uint8_t format;
+    uint8_t xy[64];
+} __attribute__((packed)) U2fPubKey;
+
+typedef struct {
+    uint8_t len;
+    uint8_t hash[32];
+    uint8_t nonce[32];
+} __attribute__((packed)) U2fKeyHandle;
+
+typedef struct {
+    uint8_t cla;
+    uint8_t ins;
+    uint8_t p1;
+    uint8_t p2;
+    uint8_t len[3];
+    uint8_t challenge[32];
+    uint8_t app_id[32];
+} __attribute__((packed)) U2fRegisterReq;
+
+typedef struct {
+    uint8_t reserved;
+    U2fPubKey pub_key;
+    U2fKeyHandle key_handle;
+    uint8_t cert[];
+} __attribute__((packed)) U2fRegisterResp;
+
+typedef struct {
+    uint8_t cla;
+    uint8_t ins;
+    uint8_t p1;
+    uint8_t p2;
+    uint8_t len[3];
+    uint8_t challenge[32];
+    uint8_t app_id[32];
+    U2fKeyHandle key_handle;
+} __attribute__((packed)) U2fAuthReq;
+
+typedef struct {
+    uint8_t user_present;
+    uint32_t counter;
+    uint8_t signature[];
+} __attribute__((packed)) U2fAuthResp;
+
+static const uint8_t ver_str[] = {"U2F_V2"};
+
+static const uint8_t state_no_error[] = {0x90, 0x00};
+static const uint8_t state_not_supported[] = {0x6D, 0x00};
+static const uint8_t state_user_missing[] = {0x69, 0x85};
+static const uint8_t state_wrong_data[] = {0x6A, 0x80};
+
+struct U2fData {
+    uint8_t device_key[32];
+    uint8_t cert_key[32];
+    uint32_t counter;
+    const struct uECC_Curve_t* p_curve;
+    bool ready;
+    bool user_present;
+    U2fEvtCallback callback;
+    void* context;
+};
+
+static int u2f_uecc_random(uint8_t* dest, unsigned size) {
+    furi_hal_random_fill_buf(dest, size);
+    return 1;
+}
+
+U2fData* u2f_alloc() {
+    return furi_alloc(sizeof(U2fData));
+}
+
+void u2f_free(U2fData* U2F) {
+    furi_assert(U2F);
+    free(U2F);
+}
+
+bool u2f_init(U2fData* U2F) {
+    furi_assert(U2F);
+
+    if(u2f_data_cert_check() == false) {
+        FURI_LOG_E(TAG, "Certificate load error");
+        return false;
+    }
+    if(u2f_data_cert_key_load(U2F->cert_key) == false) {
+        FURI_LOG_E(TAG, "Certificate key load error");
+        return false;
+    }
+    if(u2f_data_key_load(U2F->device_key) == false) {
+        FURI_LOG_W(TAG, "Key loading error, generating new");
+        if(u2f_data_key_generate(U2F->device_key) == false) {
+            FURI_LOG_E(TAG, "Key write failed");
+            return false;
+        }
+    }
+    if(u2f_data_cnt_read(&U2F->counter) == false) {
+        FURI_LOG_W(TAG, "Counter loading error, resetting counter");
+        U2F->counter = 0;
+        if(u2f_data_cnt_write(0) == false) {
+            FURI_LOG_E(TAG, "Counter write failed");
+            return false;
+        }
+    }
+
+    U2F->p_curve = uECC_secp256r1();
+    uECC_set_rng(u2f_uecc_random);
+
+    U2F->ready = true;
+    return true;
+}
+
+void u2f_set_event_callback(U2fData* U2F, U2fEvtCallback callback, void* context) {
+    furi_assert(U2F);
+    furi_assert(callback);
+    U2F->callback = callback;
+    U2F->context = context;
+}
+
+void u2f_confirm_user_present(U2fData* U2F) {
+    U2F->user_present = true;
+}
+
+static uint8_t u2f_der_encode_int(uint8_t* der, uint8_t* val, uint8_t val_len) {
+    der[0] = 0x02; // Integer
+
+    uint8_t len = 2;
+    // Omit leading zeros
+    while(val[0] == 0 && val_len > 0) {
+        ++val;
+        --val_len;
+    }
+
+    // Check if integer is negative
+    if(val[0] > 0x7f) der[len++] = 0;
+
+    memcpy(der + len, val, val_len);
+    len += val_len;
+
+    der[1] = len - 2;
+    return len;
+}
+
+static uint8_t u2f_der_encode_signature(uint8_t* der, uint8_t* sig) {
+    der[0] = 0x30;
+
+    uint8_t len = 2;
+    len += u2f_der_encode_int(der + len, sig, 32);
+    len += u2f_der_encode_int(der + len, sig + 32, 32);
+
+    der[1] = len - 2;
+    return len;
+}
+
+static uint16_t u2f_register(U2fData* U2F, uint8_t* buf) {
+    U2fRegisterReq* req = (U2fRegisterReq*)buf;
+    U2fRegisterResp* resp = (U2fRegisterResp*)buf;
+    U2fKeyHandle handle;
+    uint8_t private[32];
+    U2fPubKey pub_key;
+    uint8_t hash[32];
+    uint8_t signature[64];
+
+    if(U2F->callback != NULL) U2F->callback(U2fNotifyRegister, U2F->context);
+    if(U2F->user_present == false) {
+        memcpy(&buf[0], state_user_missing, 2);
+        return 2;
+    }
+    U2F->user_present = false;
+
+    hmac_sha256_context hmac_ctx;
+    sha256_context sha_ctx;
+
+    handle.len = 32 * 2;
+    // Generate random nonce
+    furi_hal_random_fill_buf(handle.nonce, 32);
+
+    // Generate private key
+    hmac_sha256_init(&hmac_ctx, U2F->device_key);
+    hmac_sha256_update(&hmac_ctx, req->app_id, 32);
+    hmac_sha256_update(&hmac_ctx, handle.nonce, 32);
+    hmac_sha256_finish(&hmac_ctx, U2F->device_key, private);
+
+    // Generate private key handle
+    hmac_sha256_init(&hmac_ctx, U2F->device_key);
+    hmac_sha256_update(&hmac_ctx, private, 32);
+    hmac_sha256_update(&hmac_ctx, req->app_id, 32);
+    hmac_sha256_finish(&hmac_ctx, U2F->device_key, handle.hash);
+
+    // Generate public key
+    pub_key.format = 0x04; // Uncompressed point
+    uECC_compute_public_key(private, pub_key.xy, U2F->p_curve);
+
+    // Generate signature
+    uint8_t reserved_byte = 0;
+    sha256_start(&sha_ctx);
+    sha256_update(&sha_ctx, &reserved_byte, 1);
+    sha256_update(&sha_ctx, req->app_id, 32);
+    sha256_update(&sha_ctx, req->challenge, 32);
+    sha256_update(&sha_ctx, handle.hash, handle.len);
+    sha256_update(&sha_ctx, (uint8_t*)&pub_key, 65);
+    sha256_finish(&sha_ctx, hash);
+
+    uECC_sign(U2F->cert_key, hash, 32, signature, U2F->p_curve);
+
+    // Encode response message
+    resp->reserved = 0x05;
+    memcpy(&(resp->pub_key), &pub_key, sizeof(U2fPubKey));
+    memcpy(&(resp->key_handle), &handle, sizeof(U2fKeyHandle));
+    uint32_t cert_len = u2f_data_cert_load(resp->cert);
+    uint8_t signature_len = u2f_der_encode_signature(resp->cert + cert_len, signature);
+    memcpy(resp->cert + cert_len + signature_len, state_no_error, 2);
+
+    return (sizeof(U2fRegisterResp) + cert_len + signature_len + 2);
+}
+
+static uint16_t u2f_authenticate(U2fData* U2F, uint8_t* buf) {
+    U2fAuthReq* req = (U2fAuthReq*)buf;
+    U2fAuthResp* resp = (U2fAuthResp*)buf;
+    uint8_t priv_key[32];
+    uint8_t mac_control[32];
+    hmac_sha256_context hmac_ctx;
+    sha256_context sha_ctx;
+    uint8_t flags = 0;
+    uint8_t hash[32];
+    uint8_t signature[64];
+
+    if(U2F->callback != NULL) U2F->callback(U2fNotifyAuth, U2F->context);
+    if(U2F->user_present == true) {
+        flags |= 1;
+    } else {
+        if(req->p1 == U2fEnforce) {
+            memcpy(&buf[0], state_user_missing, 2);
+            return 2;
+        }
+    }
+    U2F->user_present = false;
+
+    // Generate hash
+    sha256_start(&sha_ctx);
+    sha256_update(&sha_ctx, req->app_id, 32);
+    sha256_update(&sha_ctx, &flags, 1);
+    sha256_update(&sha_ctx, (uint8_t*)&(U2F->counter), 4);
+    sha256_update(&sha_ctx, req->challenge, 32);
+    sha256_finish(&sha_ctx, hash);
+
+    // Recover private key
+    hmac_sha256_init(&hmac_ctx, U2F->device_key);
+    hmac_sha256_update(&hmac_ctx, req->app_id, 32);
+    hmac_sha256_update(&hmac_ctx, req->key_handle.nonce, 32);
+    hmac_sha256_finish(&hmac_ctx, U2F->device_key, priv_key);
+
+    // Generate and verify private key handle
+    hmac_sha256_init(&hmac_ctx, U2F->device_key);
+    hmac_sha256_update(&hmac_ctx, priv_key, 32);
+    hmac_sha256_update(&hmac_ctx, req->app_id, 32);
+    hmac_sha256_finish(&hmac_ctx, U2F->device_key, mac_control);
+
+    if(memcmp(req->key_handle.hash, mac_control, 32) != 0) {
+        FURI_LOG_W(TAG, "Wrong handle!");
+        memcpy(&buf[0], state_wrong_data, 2);
+        return 2;
+    }
+
+    if(req->p1 == U2fCheckOnly) { // Check-only: don't need to send full response
+        memcpy(&buf[0], state_user_missing, 2);
+        return 2;
+    }
+
+    uECC_sign(priv_key, hash, 32, signature, U2F->p_curve);
+
+    resp->user_present = flags;
+    resp->counter = U2F->counter;
+    uint8_t signature_len = u2f_der_encode_signature(resp->signature, signature);
+    memcpy(resp->signature + signature_len, state_no_error, 2);
+
+    FURI_LOG_I(TAG, "Counter: %lu", U2F->counter);
+    U2F->counter++;
+    u2f_data_cnt_write(U2F->counter);
+
+    return (sizeof(U2fAuthResp) + signature_len + 2);
+}
+
+uint16_t u2f_msg_parse(U2fData* U2F, uint8_t* buf, uint16_t len) {
+    furi_assert(U2F);
+    if(!U2F->ready) return 0;
+    if((buf[0] != 0x00) && (len < 5)) return 0;
+    if(buf[1] == U2F_CMD_REGISTER) { // Register request
+        return u2f_register(U2F, buf);
+
+    } else if(buf[1] == U2F_CMD_AUTHENTICATE) { // Authenticate request
+        return u2f_authenticate(U2F, buf);
+
+    } else if(buf[1] == U2F_CMD_VERSION) { // Get U2F version string
+        memcpy(&buf[0], ver_str, 6);
+        memcpy(&buf[6], state_no_error, 2);
+        return 8;
+    } else {
+        memcpy(&buf[0], state_not_supported, 2);
+        return 2;
+    }
+    return 0;
+}
+
+void u2f_wink(U2fData* U2F) {
+    if(U2F->callback != NULL) U2F->callback(U2fNotifyWink, U2F->context);
+}
diff --git a/applications/u2f/u2f.h b/applications/u2f/u2f.h
new file mode 100644
index 00000000..5e7d7b32
--- /dev/null
+++ b/applications/u2f/u2f.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <furi.h>
+
+typedef enum {
+    U2fNotifyRegister,
+    U2fNotifyAuth,
+    U2fNotifyWink,
+} U2fNotifyEvent;
+
+typedef struct U2fData U2fData;
+
+typedef void (*U2fEvtCallback)(U2fNotifyEvent evt, void* context);
+
+U2fData* u2f_alloc();
+
+bool u2f_init(U2fData* instance);
+
+void u2f_free(U2fData* instance);
+
+void u2f_set_event_callback(U2fData* instance, U2fEvtCallback callback, void* context);
+
+void u2f_confirm_user_present(U2fData* instance);
+
+uint16_t u2f_msg_parse(U2fData* instance, uint8_t* buf, uint16_t len);
+
+void u2f_wink(U2fData* instance);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/applications/u2f/u2f_app.c b/applications/u2f/u2f_app.c
new file mode 100644
index 00000000..3a096b7e
--- /dev/null
+++ b/applications/u2f/u2f_app.c
@@ -0,0 +1,77 @@
+#include "u2f_app_i.h"
+#include <furi.h>
+#include <furi-hal.h>
+
+static bool u2f_app_custom_event_callback(void* context, uint32_t event) {
+    furi_assert(context);
+    U2fApp* app = context;
+    return scene_manager_handle_custom_event(app->scene_manager, event);
+}
+
+static bool u2f_app_back_event_callback(void* context) {
+    furi_assert(context);
+    U2fApp* app = context;
+    return scene_manager_handle_back_event(app->scene_manager);
+}
+
+static void u2f_app_tick_event_callback(void* context) {
+    furi_assert(context);
+    U2fApp* app = context;
+    scene_manager_handle_tick_event(app->scene_manager);
+}
+
+U2fApp* u2f_app_alloc() {
+    U2fApp* app = furi_alloc(sizeof(U2fApp));
+
+    app->gui = furi_record_open("gui");
+    app->notifications = furi_record_open("notification");
+
+    app->view_dispatcher = view_dispatcher_alloc();
+    app->scene_manager = scene_manager_alloc(&u2f_scene_handlers, app);
+    view_dispatcher_enable_queue(app->view_dispatcher);
+    view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
+    view_dispatcher_set_tick_event_callback(
+        app->view_dispatcher, u2f_app_tick_event_callback, 500);
+
+    view_dispatcher_set_custom_event_callback(app->view_dispatcher, u2f_app_custom_event_callback);
+    view_dispatcher_set_navigation_event_callback(
+        app->view_dispatcher, u2f_app_back_event_callback);
+
+    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
+
+    app->u2f_view = u2f_view_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, U2fAppViewMain, u2f_view_get_view(app->u2f_view));
+
+    scene_manager_next_scene(app->scene_manager, U2fAppViewMain);
+
+    return app;
+}
+
+void u2f_app_free(U2fApp* app) {
+    furi_assert(app);
+
+    // Views
+    view_dispatcher_remove_view(app->view_dispatcher, U2fAppViewMain);
+    u2f_view_free(app->u2f_view);
+
+    // View dispatcher
+    view_dispatcher_free(app->view_dispatcher);
+    scene_manager_free(app->scene_manager);
+
+    // Close records
+    furi_record_close("gui");
+    furi_record_close("notification");
+
+    free(app);
+}
+
+int32_t u2f_app(void* p) {
+    U2fApp* u2f_app = u2f_app_alloc();
+
+    view_dispatcher_run(u2f_app->view_dispatcher);
+
+    u2f_app_free(u2f_app);
+
+    return 0;
+}
diff --git a/applications/u2f/u2f_app.h b/applications/u2f/u2f_app.h
new file mode 100644
index 00000000..b19e0cca
--- /dev/null
+++ b/applications/u2f/u2f_app.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct U2fApp U2fApp;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/applications/u2f/u2f_app_i.h b/applications/u2f/u2f_app_i.h
new file mode 100644
index 00000000..6a30286e
--- /dev/null
+++ b/applications/u2f/u2f_app_i.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "u2f_app.h"
+#include "scenes/u2f_scene.h"
+
+#include <gui/gui.h>
+#include <gui/view_dispatcher.h>
+#include <gui/scene_manager.h>
+#include <gui/modules/submenu.h>
+#include <dialogs/dialogs.h>
+#include <notification/notification-messages.h>
+#include <gui/modules/variable-item-list.h>
+#include "views/u2f_view.h"
+#include "u2f_hid.h"
+#include "u2f.h"
+
+typedef enum {
+    U2fCustomEventNone,
+
+    U2fCustomEventRegister,
+    U2fCustomEventAuth,
+    U2fCustomEventWink,
+
+    U2fCustomEventTimeout,
+
+    U2fCustomEventConfirm,
+
+} GpioCustomEvent;
+
+typedef enum {
+    U2fAppViewMain,
+} U2fAppView;
+
+struct U2fApp {
+    Gui* gui;
+    ViewDispatcher* view_dispatcher;
+    SceneManager* scene_manager;
+    NotificationApp* notifications;
+    osTimerId_t timer;
+    U2fHid* u2f_hid;
+    U2fView* u2f_view;
+    U2fData* u2f_instance;
+    GpioCustomEvent event_cur;
+    bool u2f_ready;
+};
diff --git a/applications/u2f/u2f_data.c b/applications/u2f/u2f_data.c
new file mode 100644
index 00000000..038918a7
--- /dev/null
+++ b/applications/u2f/u2f_data.c
@@ -0,0 +1,382 @@
+#include <furi.h>
+#include "u2f_hid.h"
+#include <furi-hal.h>
+#include <storage/storage.h>
+#include <furi-hal-random.h>
+#include <flipper_file.h>
+
+#define TAG "U2F"
+
+#define U2F_DATA_FOLDER "/any/u2f/"
+#define U2F_CERT_FILE U2F_DATA_FOLDER "cert.der"
+#define U2F_CERT_KEY_FILE U2F_DATA_FOLDER "cert_key.u2f"
+#define U2F_KEY_FILE U2F_DATA_FOLDER "key.u2f"
+#define U2F_CNT_FILE U2F_DATA_FOLDER "cnt.u2f"
+
+#define U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_FACTORY 2
+#define U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE 11
+
+#define U2F_CERT_STOCK 0 // Stock certificate, private key is encrypted with factory key
+#define U2F_CERT_USER 1 // User certificate, private key is encrypted with unique key
+
+#define U2F_CERT_KEY_FILE_TYPE "Flipper U2F Certificate Key File"
+#define U2F_CERT_KEY_VERSION 1
+
+#define U2F_DEVICE_KEY_FILE_TYPE "Flipper U2F Device Key File"
+#define U2F_DEVICE_KEY_VERSION 1
+
+#define U2F_COUNTER_FILE_TYPE "Flipper U2F Counter File"
+#define U2F_COUNTER_VERSION 1
+
+#define U2F_COUNTER_CONTROL_VAL 0xAA5500FF
+
+typedef struct {
+    uint32_t counter;
+    uint8_t random_salt[24];
+    uint32_t control;
+} __attribute__((packed)) U2fCounterData;
+
+bool u2f_data_cert_check() {
+    bool state = false;
+    Storage* fs_api = furi_record_open("storage");
+    File* file = storage_file_alloc(fs_api);
+    uint8_t file_buf[8];
+
+    if(storage_file_open(file, U2F_CERT_FILE, FSAM_READ, FSOM_OPEN_EXISTING)) {
+        do {
+            // Read header to check certificate size
+            size_t file_size = storage_file_size(file);
+            size_t len_cur = storage_file_read(file, file_buf, 4);
+            if(len_cur != 4) break;
+
+            if(file_buf[0] != 0x30) {
+                FURI_LOG_E(TAG, "Wrong certificate header");
+                break;
+            }
+
+            size_t temp_len = ((file_buf[2] << 8) | (file_buf[3])) + 4;
+            if(temp_len != file_size) {
+                FURI_LOG_E(TAG, "Wrong certificate length");
+                break;
+            }
+            state = true;
+        } while(0);
+    }
+
+    storage_file_close(file);
+    storage_file_free(file);
+
+    furi_record_close("storage");
+
+    return state;
+}
+
+uint32_t u2f_data_cert_load(uint8_t* cert) {
+    furi_assert(cert);
+
+    Storage* fs_api = furi_record_open("storage");
+    File* file = storage_file_alloc(fs_api);
+    uint32_t file_size = 0;
+    uint32_t len_cur = 0;
+
+    if(storage_file_open(file, U2F_CERT_FILE, FSAM_READ, FSOM_OPEN_EXISTING)) {
+        file_size = storage_file_size(file);
+        len_cur = storage_file_read(file, cert, file_size);
+        if(len_cur != file_size) len_cur = 0;
+    }
+
+    storage_file_close(file);
+    storage_file_free(file);
+    furi_record_close("storage");
+
+    return len_cur;
+}
+
+bool u2f_data_cert_key_load(uint8_t* cert_key) {
+    furi_assert(cert_key);
+
+    bool state = false;
+    uint8_t iv[16];
+    uint8_t key[48];
+    uint32_t cert_type = 0;
+    uint8_t key_slot = 0;
+    uint32_t version = 0;
+
+    // Check if unique key exists in secure eclave and generate it if missing
+    if(!furi_hal_crypto_verify_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE)) return false;
+
+    string_t filetype;
+    string_init(filetype);
+
+    Storage* storage = furi_record_open("storage");
+    FlipperFile* flipper_file = flipper_file_alloc(storage);
+
+    if(flipper_file_open_existing(flipper_file, U2F_CERT_KEY_FILE)) {
+        do {
+            if(!flipper_file_read_header(flipper_file, filetype, &version)) {
+                FURI_LOG_E(TAG, "Missing or incorrect header");
+                break;
+            }
+
+            if(strcmp(string_get_cstr(filetype), U2F_CERT_KEY_FILE_TYPE) != 0 ||
+               version != U2F_CERT_KEY_VERSION) {
+                FURI_LOG_E(TAG, "Type or version mismatch");
+                break;
+            }
+
+            if(!flipper_file_read_uint32(flipper_file, "Type", &cert_type, 1)) {
+                FURI_LOG_E(TAG, "Missing cert type");
+                break;
+            }
+
+            if(cert_type == U2F_CERT_STOCK) {
+                key_slot = U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_FACTORY;
+            } else if(cert_type == U2F_CERT_USER) {
+                key_slot = U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE;
+            } else {
+                FURI_LOG_E(TAG, "Unknown cert type");
+                break;
+            }
+
+            if(!flipper_file_read_hex(flipper_file, "IV", iv, 16)) {
+                FURI_LOG_E(TAG, "Missing IV");
+                break;
+            }
+
+            if(!flipper_file_read_hex(flipper_file, "Data", key, 48)) {
+                FURI_LOG_E(TAG, "Missing data");
+                break;
+            }
+
+            if(!furi_hal_crypto_store_load_key(key_slot, iv)) {
+                FURI_LOG_E(TAG, "Unable to load encryption key");
+                break;
+            }
+            memset(cert_key, 0, 32);
+
+            if(!furi_hal_crypto_decrypt(key, cert_key, 32)) {
+                memset(cert_key, 0, 32);
+                FURI_LOG_E(TAG, "Decryption failed");
+                break;
+            }
+            furi_hal_crypto_store_unload_key(key_slot);
+            state = true;
+        } while(0);
+    }
+
+    flipper_file_close(flipper_file);
+    flipper_file_free(flipper_file);
+    furi_record_close("storage");
+    string_clear(filetype);
+
+    return state;
+}
+
+bool u2f_data_key_load(uint8_t* device_key) {
+    furi_assert(device_key);
+
+    bool state = false;
+    uint8_t iv[16];
+    uint8_t key[48];
+    uint32_t version = 0;
+
+    string_t filetype;
+    string_init(filetype);
+
+    Storage* storage = furi_record_open("storage");
+    FlipperFile* flipper_file = flipper_file_alloc(storage);
+
+    if(flipper_file_open_existing(flipper_file, U2F_KEY_FILE)) {
+        do {
+            if(!flipper_file_read_header(flipper_file, filetype, &version)) {
+                FURI_LOG_E(TAG, "Missing or incorrect header");
+                break;
+            }
+            if(strcmp(string_get_cstr(filetype), U2F_DEVICE_KEY_FILE_TYPE) != 0 ||
+               version != U2F_DEVICE_KEY_VERSION) {
+                FURI_LOG_E(TAG, "Type or version mismatch");
+                break;
+            }
+            if(!flipper_file_read_hex(flipper_file, "IV", iv, 16)) {
+                FURI_LOG_E(TAG, "Missing IV");
+                break;
+            }
+            if(!flipper_file_read_hex(flipper_file, "Data", key, 48)) {
+                FURI_LOG_E(TAG, "Missing data");
+                break;
+            }
+            if(!furi_hal_crypto_store_load_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE, iv)) {
+                FURI_LOG_E(TAG, "Unable to load encryption key");
+                break;
+            }
+            memset(device_key, 0, 32);
+            if(!furi_hal_crypto_decrypt(key, device_key, 32)) {
+                memset(device_key, 0, 32);
+                FURI_LOG_E(TAG, "Decryption failed");
+                break;
+            }
+            furi_hal_crypto_store_unload_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE);
+            state = true;
+        } while(0);
+    }
+    flipper_file_close(flipper_file);
+    flipper_file_free(flipper_file);
+    furi_record_close("storage");
+    string_clear(filetype);
+    return state;
+}
+
+bool u2f_data_key_generate(uint8_t* device_key) {
+    furi_assert(device_key);
+
+    bool state = false;
+    uint8_t iv[16];
+    uint8_t key[32];
+    uint8_t key_encrypted[48];
+
+    // Generate random IV and key
+    furi_hal_random_fill_buf(iv, 16);
+    furi_hal_random_fill_buf(key, 32);
+
+    if(!furi_hal_crypto_store_load_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE, iv)) {
+        FURI_LOG_E(TAG, "Unable to load encryption key");
+        return false;
+    }
+
+    if(!furi_hal_crypto_encrypt(key, key_encrypted, 32)) {
+        FURI_LOG_E(TAG, "Encryption failed");
+        return false;
+    }
+    furi_hal_crypto_store_unload_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE);
+
+    string_t filetype;
+    string_init(filetype);
+
+    Storage* storage = furi_record_open("storage");
+    FlipperFile* flipper_file = flipper_file_alloc(storage);
+
+    if(flipper_file_open_always(flipper_file, U2F_KEY_FILE)) {
+        do {
+            if(!flipper_file_write_header_cstr(
+                   flipper_file, U2F_DEVICE_KEY_FILE_TYPE, U2F_DEVICE_KEY_VERSION))
+                break;
+            if(!flipper_file_write_hex(flipper_file, "IV", iv, 16)) break;
+            if(!flipper_file_write_hex(flipper_file, "Data", key_encrypted, 48)) break;
+            state = true;
+            memcpy(device_key, key, 32);
+        } while(0);
+    }
+
+    flipper_file_close(flipper_file);
+    flipper_file_free(flipper_file);
+    furi_record_close("storage");
+    string_clear(filetype);
+
+    return state;
+}
+
+bool u2f_data_cnt_read(uint32_t* cnt_val) {
+    furi_assert(cnt_val);
+
+    bool state = false;
+    uint8_t iv[16];
+    U2fCounterData cnt;
+    uint8_t cnt_encr[48];
+    uint32_t version = 0;
+
+    string_t filetype;
+    string_init(filetype);
+
+    Storage* storage = furi_record_open("storage");
+    FlipperFile* flipper_file = flipper_file_alloc(storage);
+
+    if(flipper_file_open_existing(flipper_file, U2F_CNT_FILE)) {
+        do {
+            if(!flipper_file_read_header(flipper_file, filetype, &version)) {
+                FURI_LOG_E(TAG, "Missing or incorrect header");
+                break;
+            }
+            if(strcmp(string_get_cstr(filetype), U2F_COUNTER_FILE_TYPE) != 0 ||
+               version != U2F_COUNTER_VERSION) {
+                FURI_LOG_E(TAG, "Type or version mismatch");
+                break;
+            }
+            if(!flipper_file_read_hex(flipper_file, "IV", iv, 16)) {
+                FURI_LOG_E(TAG, "Missing IV");
+                break;
+            }
+            if(!flipper_file_read_hex(flipper_file, "Data", cnt_encr, 48)) {
+                FURI_LOG_E(TAG, "Missing data");
+                break;
+            }
+            if(!furi_hal_crypto_store_load_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE, iv)) {
+                FURI_LOG_E(TAG, "Unable to load encryption key");
+                break;
+            }
+            memset(&cnt, 0, 32);
+            if(!furi_hal_crypto_decrypt(cnt_encr, (uint8_t*)&cnt, 32)) {
+                memset(&cnt, 0, 32);
+                FURI_LOG_E(TAG, "Decryption failed");
+                break;
+            }
+            furi_hal_crypto_store_unload_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE);
+            if(cnt.control == U2F_COUNTER_CONTROL_VAL) {
+                *cnt_val = cnt.counter;
+                state = true;
+            }
+        } while(0);
+    }
+    flipper_file_close(flipper_file);
+    flipper_file_free(flipper_file);
+    furi_record_close("storage");
+    string_clear(filetype);
+    return state;
+}
+
+bool u2f_data_cnt_write(uint32_t cnt_val) {
+    bool state = false;
+    uint8_t iv[16];
+    U2fCounterData cnt;
+    uint8_t cnt_encr[48];
+
+    // Generate random IV and key
+    furi_hal_random_fill_buf(iv, 16);
+    furi_hal_random_fill_buf(cnt.random_salt, 24);
+    cnt.control = U2F_COUNTER_CONTROL_VAL;
+    cnt.counter = cnt_val;
+
+    if(!furi_hal_crypto_store_load_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE, iv)) {
+        FURI_LOG_E(TAG, "Unable to load encryption key");
+        return false;
+    }
+
+    if(!furi_hal_crypto_encrypt((uint8_t*)&cnt, cnt_encr, 32)) {
+        FURI_LOG_E(TAG, "Encryption failed");
+        return false;
+    }
+    furi_hal_crypto_store_unload_key(U2F_DATA_FILE_ENCRYPTION_KEY_SLOT_UNIQUE);
+
+    string_t filetype;
+    string_init(filetype);
+
+    Storage* storage = furi_record_open("storage");
+    FlipperFile* flipper_file = flipper_file_alloc(storage);
+
+    if(flipper_file_open_always(flipper_file, U2F_CNT_FILE)) {
+        do {
+            if(!flipper_file_write_header_cstr(
+                   flipper_file, U2F_COUNTER_FILE_TYPE, U2F_COUNTER_VERSION))
+                break;
+            if(!flipper_file_write_hex(flipper_file, "IV", iv, 16)) break;
+            if(!flipper_file_write_hex(flipper_file, "Data", cnt_encr, 48)) break;
+            state = true;
+        } while(0);
+    }
+
+    flipper_file_close(flipper_file);
+    flipper_file_free(flipper_file);
+    furi_record_close("storage");
+    string_clear(filetype);
+
+    return state;
+}
diff --git a/applications/u2f/u2f_data.h b/applications/u2f/u2f_data.h
new file mode 100644
index 00000000..e47e26a1
--- /dev/null
+++ b/applications/u2f/u2f_data.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <furi.h>
+
+bool u2f_data_cert_check();
+
+uint32_t u2f_data_cert_load(uint8_t* cert);
+
+bool u2f_data_cert_key_load(uint8_t* cert_key);
+
+bool u2f_data_key_load(uint8_t* device_key);
+
+bool u2f_data_key_generate(uint8_t* device_key);
+
+bool u2f_data_cnt_read(uint32_t* cnt);
+
+bool u2f_data_cnt_write(uint32_t cnt);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/applications/u2f/u2f_hid.c b/applications/u2f/u2f_hid.c
new file mode 100644
index 00000000..34767c42
--- /dev/null
+++ b/applications/u2f/u2f_hid.c
@@ -0,0 +1,293 @@
+#include <furi.h>
+#include "u2f_hid.h"
+#include "u2f.h"
+#include <furi-hal.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <lib/toolbox/args.h>
+#include <furi-hal-usb-hid-u2f.h>
+#include <storage/storage.h>
+
+#include <furi-hal-console.h>
+
+#define TAG "U2FHID"
+#define WORKER_TAG TAG "Worker"
+
+#define U2F_HID_MAX_PAYLOAD_LEN ((HID_U2F_PACKET_LEN - 7) + 128 * (HID_U2F_PACKET_LEN - 5))
+
+#define U2F_HID_TYPE_MASK 0x80 // Frame type mask
+#define U2F_HID_TYPE_INIT 0x80 // Initial frame identifier
+#define U2F_HID_TYPE_CONT 0x00 // Continuation frame identifier
+
+#define U2F_HID_PING (U2F_HID_TYPE_INIT | 0x01) // Echo data through local processor only
+#define U2F_HID_MSG (U2F_HID_TYPE_INIT | 0x03) // Send U2F message frame
+#define U2F_HID_LOCK (U2F_HID_TYPE_INIT | 0x04) // Send lock channel command
+#define U2F_HID_INIT (U2F_HID_TYPE_INIT | 0x06) // Channel initialization
+#define U2F_HID_WINK (U2F_HID_TYPE_INIT | 0x08) // Send device identification wink
+#define U2F_HID_ERROR (U2F_HID_TYPE_INIT | 0x3f) // Error response
+
+#define U2F_HID_ERR_NONE 0x00 // No error
+#define U2F_HID_ERR_INVALID_CMD 0x01 // Invalid command
+#define U2F_HID_ERR_INVALID_PAR 0x02 // Invalid parameter
+#define U2F_HID_ERR_INVALID_LEN 0x03 // Invalid message length
+#define U2F_HID_ERR_INVALID_SEQ 0x04 // Invalid message sequencing
+#define U2F_HID_ERR_MSG_TIMEOUT 0x05 // Message has timed out
+#define U2F_HID_ERR_CHANNEL_BUSY 0x06 // Channel busy
+#define U2F_HID_ERR_LOCK_REQUIRED 0x0a // Command requires channel lock
+#define U2F_HID_ERR_SYNC_FAIL 0x0b // SYNC command failed
+#define U2F_HID_ERR_OTHER 0x7f // Other unspecified error
+
+#define U2F_HID_BROADCAST_CID 0xFFFFFFFF
+
+typedef enum {
+    WorkerEvtReserved = (1 << 0),
+    WorkerEvtStop = (1 << 1),
+    WorkerEvtConnect = (1 << 2),
+    WorkerEvtDisconnect = (1 << 3),
+    WorkerEvtRequest = (1 << 4),
+    WorkerEvtUnlock = (1 << 5),
+} WorkerEvtFlags;
+
+struct U2fHid_packet {
+    uint32_t cid;
+    uint16_t len;
+    uint8_t cmd;
+    uint8_t payload[U2F_HID_MAX_PAYLOAD_LEN];
+};
+
+struct U2fHid {
+    FuriThread* thread;
+    osTimerId_t lock_timer;
+    struct U2fHid_packet packet;
+    uint8_t seq_id_last;
+    uint16_t req_buf_ptr;
+    uint32_t req_len_left;
+    uint32_t lock_cid;
+    bool lock;
+    U2fData* u2f_instance;
+};
+
+static void u2f_hid_event_callback(HidU2fEvent ev, void* context) {
+    furi_assert(context);
+    U2fHid* u2f_hid = context;
+
+    if(ev == HidU2fDisconnected)
+        osThreadFlagsSet(furi_thread_get_thread_id(u2f_hid->thread), WorkerEvtDisconnect);
+    else if(ev == HidU2fConnected)
+        osThreadFlagsSet(furi_thread_get_thread_id(u2f_hid->thread), WorkerEvtConnect);
+    else if(ev == HidU2fRequest)
+        osThreadFlagsSet(furi_thread_get_thread_id(u2f_hid->thread), WorkerEvtRequest);
+}
+
+static void u2f_hid_lock_timeout_callback(void* context) {
+    furi_assert(context);
+    U2fHid* u2f_hid = context;
+
+    osThreadFlagsSet(furi_thread_get_thread_id(u2f_hid->thread), WorkerEvtUnlock);
+}
+
+static void u2f_hid_send_response(U2fHid* u2f_hid) {
+    uint8_t packet_buf[HID_U2F_PACKET_LEN];
+    uint16_t len_remain = u2f_hid->packet.len;
+    uint8_t len_cur = 0;
+    uint8_t seq_cnt = 0;
+    uint16_t data_ptr = 0;
+
+    memset(packet_buf, 0, HID_U2F_PACKET_LEN);
+    memcpy(packet_buf, &(u2f_hid->packet.cid), 4);
+
+    // Init packet
+    packet_buf[4] = u2f_hid->packet.cmd;
+    packet_buf[5] = u2f_hid->packet.len >> 8;
+    packet_buf[6] = (u2f_hid->packet.len & 0xFF);
+    len_cur = (len_remain < (HID_U2F_PACKET_LEN - 7)) ? (len_remain) : (HID_U2F_PACKET_LEN - 7);
+    if(len_cur > 0) memcpy(&packet_buf[7], u2f_hid->packet.payload, len_cur);
+    furi_hal_hid_u2f_send_response(packet_buf, HID_U2F_PACKET_LEN);
+    data_ptr = len_cur;
+    len_remain -= len_cur;
+
+    // Continuation packets
+    while(len_remain > 0) {
+        memset(&packet_buf[4], 0, HID_U2F_PACKET_LEN - 4);
+        packet_buf[4] = seq_cnt;
+        len_cur = (len_remain < (HID_U2F_PACKET_LEN - 5)) ? (len_remain) :
+                                                            (HID_U2F_PACKET_LEN - 5);
+        memcpy(&packet_buf[5], &(u2f_hid->packet.payload[data_ptr]), len_cur);
+        furi_hal_hid_u2f_send_response(packet_buf, HID_U2F_PACKET_LEN);
+        seq_cnt++;
+        len_remain -= len_cur;
+        data_ptr += len_cur;
+    }
+}
+
+static void u2f_hid_send_error(U2fHid* u2f_hid, uint8_t error) {
+    u2f_hid->packet.len = 1;
+    u2f_hid->packet.cmd = U2F_HID_ERROR;
+    u2f_hid->packet.payload[0] = error;
+    u2f_hid_send_response(u2f_hid);
+}
+
+static bool u2f_hid_parse_request(U2fHid* u2f_hid) {
+    FURI_LOG_I(
+        WORKER_TAG,
+        "Req cid=%lX cmd=%x len=%u",
+        u2f_hid->packet.cid,
+        u2f_hid->packet.cmd,
+        u2f_hid->packet.len);
+
+    if(u2f_hid->packet.cmd == U2F_HID_PING) { // PING - echo request back
+        u2f_hid_send_response(u2f_hid);
+
+    } else if(u2f_hid->packet.cmd == U2F_HID_MSG) { // MSG - U2F message
+        if((u2f_hid->lock == true) && (u2f_hid->packet.cid != u2f_hid->lock_cid)) return false;
+        uint16_t resp_len =
+            u2f_msg_parse(u2f_hid->u2f_instance, u2f_hid->packet.payload, u2f_hid->packet.len);
+        if(resp_len > 0) {
+            u2f_hid->packet.len = resp_len;
+            u2f_hid_send_response(u2f_hid);
+        } else
+            return false;
+
+    } else if(u2f_hid->packet.cmd == U2F_HID_LOCK) { // LOCK - lock all channels except current
+        if(u2f_hid->packet.len != 1) return false;
+        uint8_t lock_timeout = u2f_hid->packet.payload[0];
+        if(lock_timeout == 0) { // Lock off
+            u2f_hid->lock = false;
+            u2f_hid->lock_cid = 0;
+        } else { // Lock on
+            u2f_hid->lock = true;
+            u2f_hid->lock_cid = u2f_hid->packet.cid;
+            osTimerStart(u2f_hid->lock_timer, lock_timeout * 1000);
+        }
+
+    } else if(u2f_hid->packet.cmd == U2F_HID_INIT) { // INIT - channel initialization request
+        if((u2f_hid->packet.len != 8) || (u2f_hid->packet.cid != U2F_HID_BROADCAST_CID) ||
+           (u2f_hid->lock == true))
+            return false;
+        u2f_hid->packet.len = 17;
+        uint32_t random_cid = furi_hal_random_get();
+        memcpy(&(u2f_hid->packet.payload[8]), &random_cid, 4);
+        u2f_hid->packet.payload[12] = 2; // Protocol version
+        u2f_hid->packet.payload[13] = 1; // Device version major
+        u2f_hid->packet.payload[14] = 0; // Device version minor
+        u2f_hid->packet.payload[15] = 1; // Device build version
+        u2f_hid->packet.payload[16] = 1; // Capabilities: wink
+        u2f_hid_send_response(u2f_hid);
+
+    } else if(u2f_hid->packet.cmd == U2F_HID_WINK) { // WINK - notify user
+        if(u2f_hid->packet.len != 0) return false;
+        u2f_wink(u2f_hid->u2f_instance);
+        u2f_hid->packet.len = 0;
+        u2f_hid_send_response(u2f_hid);
+    } else
+        return false;
+    return true;
+}
+
+static int32_t u2f_hid_worker(void* context) {
+    U2fHid* u2f_hid = context;
+    uint8_t packet_buf[HID_U2F_PACKET_LEN];
+
+    FURI_LOG_I(WORKER_TAG, "Init");
+
+    UsbInterface* usb_mode_prev = furi_hal_usb_get_config();
+    furi_hal_usb_set_config(&usb_hid_u2f);
+
+    u2f_hid->lock_timer = osTimerNew(u2f_hid_lock_timeout_callback, osTimerOnce, u2f_hid, NULL);
+
+    furi_hal_hid_u2f_set_callback(u2f_hid_event_callback, u2f_hid);
+
+    while(1) {
+        uint32_t flags = osThreadFlagsWait(
+            WorkerEvtStop | WorkerEvtConnect | WorkerEvtDisconnect | WorkerEvtRequest,
+            osFlagsWaitAny,
+            osWaitForever);
+        furi_check((flags & osFlagsError) == 0);
+        if(flags & WorkerEvtStop) break;
+        if(flags & WorkerEvtConnect) FURI_LOG_I(WORKER_TAG, "Connect");
+        if(flags & WorkerEvtDisconnect) FURI_LOG_I(WORKER_TAG, "Disconnect");
+        if(flags & WorkerEvtRequest) {
+            uint32_t len_cur = furi_hal_hid_u2f_get_request(packet_buf);
+            if(len_cur > 0) {
+                if((packet_buf[4] & U2F_HID_TYPE_MASK) == U2F_HID_TYPE_INIT) {
+                    // Init packet
+                    u2f_hid->packet.len = (packet_buf[5] << 8) | (packet_buf[6]);
+                    if(u2f_hid->packet.len > (len_cur - 7)) {
+                        u2f_hid->req_len_left = u2f_hid->packet.len - (len_cur - 7);
+                        len_cur = len_cur - 7;
+                    } else {
+                        u2f_hid->req_len_left = 0;
+                        len_cur = u2f_hid->packet.len;
+                    }
+                    memcpy(&(u2f_hid->packet.cid), packet_buf, 4);
+                    u2f_hid->packet.cmd = packet_buf[4];
+                    u2f_hid->seq_id_last = 0;
+                    u2f_hid->req_buf_ptr = len_cur;
+                    if(len_cur > 0) memcpy(u2f_hid->packet.payload, &packet_buf[7], len_cur);
+                } else {
+                    // Continuation packet
+                    if(u2f_hid->req_len_left > 0) {
+                        uint32_t cid_temp = 0;
+                        memcpy(&cid_temp, packet_buf, 4);
+                        uint8_t seq_temp = packet_buf[4];
+                        if((cid_temp == u2f_hid->packet.cid) &&
+                           (seq_temp == u2f_hid->seq_id_last)) {
+                            if(u2f_hid->req_len_left > (len_cur - 5)) {
+                                len_cur = len_cur - 5;
+                                u2f_hid->req_len_left -= len_cur;
+                            } else {
+                                len_cur = u2f_hid->req_len_left;
+                                u2f_hid->req_len_left = 0;
+                            }
+                            memcpy(
+                                &(u2f_hid->packet.payload[u2f_hid->req_buf_ptr]),
+                                &packet_buf[5],
+                                len_cur);
+                            u2f_hid->req_buf_ptr += len_cur;
+                            u2f_hid->seq_id_last++;
+                        }
+                    }
+                }
+                if(u2f_hid->req_len_left == 0) {
+                    if(u2f_hid_parse_request(u2f_hid) == false) {
+                        u2f_hid_send_error(u2f_hid, U2F_HID_ERR_INVALID_CMD);
+                    }
+                }
+            }
+        }
+        if(flags & WorkerEvtUnlock) {
+            u2f_hid->lock = false;
+            u2f_hid->lock_cid = 0;
+        }
+    }
+    osTimerStop(u2f_hid->lock_timer);
+    osTimerDelete(u2f_hid->lock_timer);
+
+    furi_hal_hid_u2f_set_callback(NULL, NULL);
+    furi_hal_usb_set_config(usb_mode_prev);
+    FURI_LOG_I(WORKER_TAG, "End");
+
+    return 0;
+}
+
+U2fHid* u2f_hid_start(U2fData* u2f_inst) {
+    U2fHid* u2f_hid = furi_alloc(sizeof(U2fHid));
+
+    u2f_hid->u2f_instance = u2f_inst;
+
+    u2f_hid->thread = furi_thread_alloc();
+    furi_thread_set_name(u2f_hid->thread, "U2fHidWorker");
+    furi_thread_set_stack_size(u2f_hid->thread, 2048);
+    furi_thread_set_context(u2f_hid->thread, u2f_hid);
+    furi_thread_set_callback(u2f_hid->thread, u2f_hid_worker);
+    furi_thread_start(u2f_hid->thread);
+    return u2f_hid;
+}
+
+void u2f_hid_stop(U2fHid* u2f_hid) {
+    furi_assert(u2f_hid);
+    osThreadFlagsSet(furi_thread_get_thread_id(u2f_hid->thread), WorkerEvtStop);
+    furi_thread_join(u2f_hid->thread);
+    furi_thread_free(u2f_hid->thread);
+    free(u2f_hid);
+}
diff --git a/applications/u2f/u2f_hid.h b/applications/u2f/u2f_hid.h
new file mode 100644
index 00000000..2b943007
--- /dev/null
+++ b/applications/u2f/u2f_hid.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <furi.h>
+#include "u2f.h"
+
+typedef struct U2fHid U2fHid;
+
+U2fHid* u2f_hid_start(U2fData* u2f_inst);
+
+void u2f_hid_stop(U2fHid* u2f_hid);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/applications/u2f/views/u2f_view.c b/applications/u2f/views/u2f_view.c
new file mode 100644
index 00000000..b013638c
--- /dev/null
+++ b/applications/u2f/views/u2f_view.c
@@ -0,0 +1,91 @@
+#include "u2f_view.h"
+#include <gui/elements.h>
+
+struct U2fView {
+    View* view;
+    U2fOkCallback callback;
+    void* context;
+};
+
+typedef struct {
+    U2fViewMsg display_msg;
+} U2fModel;
+
+static void u2f_view_draw_callback(Canvas* canvas, void* _model) {
+    U2fModel* model = _model;
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(canvas, 0, 0, AlignLeft, AlignTop, "U2F Demo");
+
+    if(model->display_msg == U2fMsgRegister) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 0, 45, AlignLeft, AlignBottom, "Registration");
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(canvas, 0, 63, AlignLeft, AlignBottom, "Press [OK] to confirm");
+    } else if(model->display_msg == U2fMsgAuth) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 0, 45, AlignLeft, AlignBottom, "Authentication");
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str_aligned(canvas, 0, 63, AlignLeft, AlignBottom, "Press [OK] to confirm");
+    } else if(model->display_msg == U2fMsgError) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str_aligned(canvas, 64, 40, AlignCenter, AlignCenter, "U2F data missing");
+    }
+}
+
+static bool u2f_view_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    U2fView* u2f = context;
+    bool consumed = false;
+
+    if(event->type == InputTypeShort) {
+        if(event->key == InputKeyOk) {
+            consumed = true;
+            if(u2f->callback != NULL) u2f->callback(InputTypeShort, u2f->context);
+        }
+    }
+
+    return consumed;
+}
+
+U2fView* u2f_view_alloc() {
+    U2fView* u2f = furi_alloc(sizeof(U2fView));
+
+    u2f->view = view_alloc();
+    view_allocate_model(u2f->view, ViewModelTypeLocking, sizeof(U2fModel));
+    view_set_context(u2f->view, u2f);
+    view_set_draw_callback(u2f->view, u2f_view_draw_callback);
+    view_set_input_callback(u2f->view, u2f_view_input_callback);
+
+    return u2f;
+}
+
+void u2f_view_free(U2fView* u2f) {
+    furi_assert(u2f);
+    view_free(u2f->view);
+    free(u2f);
+}
+
+View* u2f_view_get_view(U2fView* u2f) {
+    furi_assert(u2f);
+    return u2f->view;
+}
+
+void u2f_view_set_ok_callback(U2fView* u2f, U2fOkCallback callback, void* context) {
+    furi_assert(u2f);
+    furi_assert(callback);
+    with_view_model(
+        u2f->view, (U2fModel * model) {
+            u2f->callback = callback;
+            u2f->context = context;
+            return false;
+        });
+}
+
+void u2f_view_set_state(U2fView* u2f, U2fViewMsg msg) {
+    with_view_model(
+        u2f->view, (U2fModel * model) {
+            model->display_msg = msg;
+            return false;
+        });
+}
diff --git a/applications/u2f/views/u2f_view.h b/applications/u2f/views/u2f_view.h
new file mode 100644
index 00000000..a222fbc3
--- /dev/null
+++ b/applications/u2f/views/u2f_view.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct U2fView U2fView;
+typedef void (*U2fOkCallback)(InputType type, void* context);
+
+typedef enum {
+    U2fMsgNone,
+    U2fMsgRegister,
+    U2fMsgAuth,
+    U2fMsgError,
+} U2fViewMsg;
+
+U2fView* u2f_view_alloc();
+
+void u2f_view_free(U2fView* u2f);
+
+View* u2f_view_get_view(U2fView* u2f);
+
+void u2f_view_set_ok_callback(U2fView* u2f, U2fOkCallback callback, void* context);
+
+void u2f_view_set_state(U2fView* u2f, U2fViewMsg msg);
diff --git a/assets/resources/u2f/cert.der b/assets/resources/u2f/cert.der
new file mode 100644
index 00000000..73efb231
Binary files /dev/null and b/assets/resources/u2f/cert.der differ
diff --git a/assets/resources/u2f/cert_key.u2f b/assets/resources/u2f/cert_key.u2f
new file mode 100644
index 00000000..116d1411
--- /dev/null
+++ b/assets/resources/u2f/cert_key.u2f
@@ -0,0 +1,5 @@
+Filetype: Flipper U2F Certificate Key File
+Version: 1
+Type: 0
+IV: E1 56 CE 83 98 FA 59 0D 45 EC 1C EB 34 FC 08 C9
+Data: E1 8C C9 9A 98 F7 B9 50 1E 85 71 8F A4 CE 76 95 87 4F AC 8B 5E D0 1F 13 BA 3B 2E E7 98 73 54 64 58 0A 00 20 55 B8 00 08 58 0A 00 20 50 4E 01 20
diff --git a/firmware/targets/f6/furi-hal/furi-hal-crypto.c b/firmware/targets/f6/furi-hal/furi-hal-crypto.c
index 91875d23..f5398421 100644
--- a/firmware/targets/f6/furi-hal/furi-hal-crypto.c
+++ b/firmware/targets/f6/furi-hal/furi-hal-crypto.c
@@ -1,5 +1,6 @@
 #include <furi-hal-crypto.h>
 #include <furi-hal-bt.h>
+#include <furi-hal-random.h>
 #include <furi.h>
 #include <shci.h>
 
@@ -7,10 +8,119 @@
 
 CRYP_HandleTypeDef crypt;
 
+#define ENCLAVE_FACTORY_KEY_SLOTS 10
+#define ENCLAVE_SIGNATURE_SIZE 16
+
+static const uint8_t enclave_signature_iv[ENCLAVE_FACTORY_KEY_SLOTS][16] = {
+    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
+    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
+    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
+    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
+    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
+    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
+    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
+    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
+    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
+    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
+};
+
+static const uint8_t enclave_signature_input[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
+    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
+    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
+    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
+    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
+    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
+    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
+    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
+    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
+    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
+};
+
+static const uint8_t enclave_signature_expected[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
+    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
+    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
+    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
+    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
+    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
+    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
+    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
+    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
+    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
+};
+
 void furi_hal_crypto_init() {
     FURI_LOG_I(TAG, "Init OK");
 }
 
+static bool furi_hal_crypto_generate_unique_keys(uint8_t start_slot, uint8_t end_slot) {
+    FuriHalCryptoKey key;
+    uint8_t key_data[32];
+    FURI_LOG_I(TAG, "Generating keys %u..%u", start_slot, end_slot);
+    for (uint8_t slot = start_slot; slot <= end_slot; slot++) {
+        key.type = FuriHalCryptoKeyTypeSimple;
+        key.size = FuriHalCryptoKeySize256;
+        key.data = key_data;
+        furi_hal_random_fill_buf(key_data, 32);
+        if (!furi_hal_crypto_store_add_key(&key, &slot)) {
+            FURI_LOG_E(TAG, "Error writing key to slot %u", slot);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_key(uint8_t key_slot) {
+    uint8_t keys_nb = 0;
+    uint8_t valid_keys_nb = 0;
+    uint8_t last_valid_slot = ENCLAVE_FACTORY_KEY_SLOTS;
+    uint8_t empty_iv[16];
+    furi_hal_crypto_verify_enclave(&keys_nb, &valid_keys_nb);
+    if (key_slot <= ENCLAVE_FACTORY_KEY_SLOTS) { // It's a factory key
+        if (key_slot > keys_nb)
+            return false;
+    } else { // Unique key
+        if (keys_nb < ENCLAVE_FACTORY_KEY_SLOTS) // Some factory keys are missing
+            return false;
+        for (uint8_t i = key_slot; i > ENCLAVE_FACTORY_KEY_SLOTS; i--) {
+            if(furi_hal_crypto_store_load_key(i, empty_iv)) {
+                last_valid_slot = i;
+                furi_hal_crypto_store_unload_key(i);
+                break;
+            }
+        }
+        if (last_valid_slot == key_slot)
+            return true;
+        else // Generate missing unique keys
+            return furi_hal_crypto_generate_unique_keys(last_valid_slot+1, key_slot);
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_enclave(uint8_t* keys_nb, uint8_t* valid_keys_nb) {
+    furi_assert(keys_nb);
+    furi_assert(valid_keys_nb);
+    uint8_t keys = 0;
+    uint8_t keys_valid = 0;
+    uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
+    for(size_t key_slot = 0; key_slot < ENCLAVE_FACTORY_KEY_SLOTS; key_slot++) {
+        if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
+            keys++;
+            if(furi_hal_crypto_encrypt(enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
+                keys_valid += memcmp(buffer, enclave_signature_expected[key_slot], ENCLAVE_SIGNATURE_SIZE) == 0;
+            }
+            furi_hal_crypto_store_unload_key(key_slot + 1);
+        }
+    }
+    *keys_nb = keys;
+    *valid_keys_nb = keys_valid;
+    if (*valid_keys_nb == ENCLAVE_FACTORY_KEY_SLOTS)
+        return true;
+    else
+        return false;
+}
+
 bool furi_hal_crypto_store_add_key(FuriHalCryptoKey* key, uint8_t* slot) {
     furi_assert(key);
     furi_assert(slot);
diff --git a/firmware/targets/f6/furi-hal/furi-hal-info.c b/firmware/targets/f6/furi-hal/furi-hal-info.c
index 783a5113..c1225ac9 100644
--- a/firmware/targets/f6/furi-hal/furi-hal-info.c
+++ b/firmware/targets/f6/furi-hal/furi-hal-info.c
@@ -2,48 +2,6 @@
 #include <furi-hal.h>
 #include <shci.h>
 
-#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
-#define ENCLAVE_SIGNATURE_SIZE 16
-
-static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
-    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
-    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
-    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
-    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
-    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
-    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
-    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
-    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
-    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
-    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
-};
-
-static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
-    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
-    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
-    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
-    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
-    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
-    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
-    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
-    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
-    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
-};
-
-static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
-    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
-    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
-    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
-    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
-    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
-    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
-    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
-    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
-    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
-};
-
 void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
     string_t value;
     string_init(value);
@@ -164,23 +122,12 @@ void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
         out("radio_ble_mac", string_get_cstr(value), false, context);
 
         // Signature verification
-        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
-        size_t enclave_valid_keys = 0;
-        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
-            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
-                if(furi_hal_crypto_encrypt(
-                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
-                    enclave_valid_keys += memcmp(
-                                              buffer,
-                                              enclave_signature_expected[key_slot],
-                                              ENCLAVE_SIGNATURE_SIZE) == 0;
-                }
-                furi_hal_crypto_store_unload_key(key_slot + 1);
-            }
-        }
+        uint8_t enclave_keys = 0;
+        uint8_t enclave_valid_keys = 0;
+        bool enclave_valid = furi_hal_crypto_verify_enclave(&enclave_keys, &enclave_valid_keys);
         string_printf(value, "%d", enclave_valid_keys);
         out("enclave_valid_keys", string_get_cstr(value), false, context);
-        out("enclave_valid", (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false", true, context);
+        out("enclave_valid", enclave_valid ? "true" : "false", true, context);
     } else {
         out("radio_alive", "false", true, context);
     }
diff --git a/firmware/targets/f6/furi-hal/furi-hal-random.c b/firmware/targets/f6/furi-hal/furi-hal-random.c
new file mode 100644
index 00000000..a7bc3a31
--- /dev/null
+++ b/firmware/targets/f6/furi-hal/furi-hal-random.c
@@ -0,0 +1,56 @@
+#include "furi-hal-random.h"
+#include <furi.h>
+#include <furi-hal.h>
+
+#include <stm32wbxx_ll_rng.h>
+#include <stm32wbxx_ll_hsem.h>
+
+#include <hw_conf.h>
+
+uint32_t furi_hal_random_get() {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+    if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+        furi_crash("TRNG error");
+    }
+
+    uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+
+    return random_val;
+}
+
+void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len) {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    for (uint32_t i = 0; i < len; i+= 4) {
+        while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+        if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+            furi_crash("TRNG error");
+        }
+
+        uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+        uint8_t len_cur = ((i+4) < len) ? (4) : (len-i);
+        memcpy(&buf[i], &random_val, len_cur);
+    }
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+}
+
+void srand(unsigned seed) {
+}
+
+int rand() {
+    return (furi_hal_random_get() & RAND_MAX);
+}
diff --git a/firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c b/firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c
new file mode 100644
index 00000000..a7426c82
--- /dev/null
+++ b/firmware/targets/f6/furi-hal/furi-hal-usb-u2f.c
@@ -0,0 +1,309 @@
+#include "furi-hal-version.h"
+#include "furi-hal-usb_i.h"
+#include "furi-hal-usb-hid-u2f.h"
+#include "furi-hal-usb.h"
+#include <furi.h>
+#include "usb.h"
+#include "usb_hid.h"
+
+#define HID_PAGE_FIDO 0xF1D0
+#define HID_FIDO_U2F 0x01
+#define HID_FIDO_INPUT 0x20
+#define HID_FIDO_OUTPUT 0x21
+
+#define HID_EP_IN 0x81
+#define HID_EP_OUT 0x01
+
+struct HidIadDescriptor {
+    struct usb_iad_descriptor hid_iad;
+    struct usb_interface_descriptor hid;
+    struct usb_hid_descriptor hid_desc;
+    struct usb_endpoint_descriptor hid_ep_in;
+    struct usb_endpoint_descriptor hid_ep_out;
+};
+
+struct HidConfigDescriptor {
+    struct usb_config_descriptor config;
+    struct HidIadDescriptor iad_0;
+} __attribute__((packed));
+
+/* HID report: FIDO U2F */
+static const uint8_t hid_u2f_report_desc[] = {
+    HID_RI_USAGE_PAGE(16, HID_PAGE_FIDO),
+    HID_USAGE(HID_FIDO_U2F),
+    HID_COLLECTION(HID_APPLICATION_COLLECTION),
+    HID_USAGE(HID_FIDO_INPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_USAGE(HID_FIDO_OUTPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_END_COLLECTION,
+};
+
+static const struct usb_string_descriptor dev_manuf_desc = USB_STRING_DESC("Flipper Devices Inc.");
+static const struct usb_string_descriptor dev_prod_desc = USB_STRING_DESC("U2F Token test");
+static const struct usb_string_descriptor dev_serial_desc = USB_STRING_DESC("TODO: serial");
+
+/* Device descriptor */
+static const struct usb_device_descriptor hid_u2f_device_desc = {
+    .bLength = sizeof(struct usb_device_descriptor),
+    .bDescriptorType = USB_DTYPE_DEVICE,
+    .bcdUSB = VERSION_BCD(2, 0, 0),
+    .bDeviceClass = USB_CLASS_IAD,
+    .bDeviceSubClass = USB_SUBCLASS_IAD,
+    .bDeviceProtocol = USB_PROTO_IAD,
+    .bMaxPacketSize0 = USB_EP0_SIZE,
+    .idVendor = 0x0483,
+    .idProduct = 0x5741,
+    .bcdDevice = VERSION_BCD(1, 0, 0),
+    .iManufacturer = UsbDevManuf,
+    .iProduct = UsbDevProduct,
+    .iSerialNumber = UsbDevSerial,
+    .bNumConfigurations = 1,
+};
+
+/* Device configuration descriptor */
+static const struct HidConfigDescriptor hid_u2f_cfg_desc = {
+    .config =
+        {
+            .bLength = sizeof(struct usb_config_descriptor),
+            .bDescriptorType = USB_DTYPE_CONFIGURATION,
+            .wTotalLength = sizeof(struct HidConfigDescriptor),
+            .bNumInterfaces = 1,
+            .bConfigurationValue = 1,
+            .iConfiguration = NO_DESCRIPTOR,
+            .bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
+            .bMaxPower = USB_CFG_POWER_MA(100),
+        },
+    .iad_0 =
+        {
+            .hid_iad =
+                {
+                    .bLength = sizeof(struct usb_iad_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFASEASSOC,
+                    .bFirstInterface = 0,
+                    .bInterfaceCount = 1,
+                    .bFunctionClass = USB_CLASS_PER_INTERFACE,
+                    .bFunctionSubClass = USB_SUBCLASS_NONE,
+                    .bFunctionProtocol = USB_PROTO_NONE,
+                    .iFunction = NO_DESCRIPTOR,
+                },
+            .hid =
+                {
+                    .bLength = sizeof(struct usb_interface_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFACE,
+                    .bInterfaceNumber = 0,
+                    .bAlternateSetting = 0,
+                    .bNumEndpoints = 2,
+                    .bInterfaceClass = USB_CLASS_HID,
+                    .bInterfaceSubClass = USB_HID_SUBCLASS_NONBOOT,
+                    .bInterfaceProtocol = USB_HID_PROTO_NONBOOT,
+                    .iInterface = NO_DESCRIPTOR,
+                },
+            .hid_desc =
+                {
+                    .bLength = sizeof(struct usb_hid_descriptor),
+                    .bDescriptorType = USB_DTYPE_HID,
+                    .bcdHID = VERSION_BCD(1, 0, 0),
+                    .bCountryCode = USB_HID_COUNTRY_NONE,
+                    .bNumDescriptors = 1,
+                    .bDescriptorType0 = USB_DTYPE_HID_REPORT,
+                    .wDescriptorLength0 = sizeof(hid_u2f_report_desc),
+                },
+            .hid_ep_in =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_IN,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+            .hid_ep_out =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_OUT,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+        },
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf);
+static void hid_u2f_deinit(usbd_device* dev);
+static void hid_u2f_on_wakeup(usbd_device* dev);
+static void hid_u2f_on_suspend(usbd_device* dev);
+
+//static bool hid_u2f_send_report(uint8_t report_id);
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg);
+static usbd_respond
+    hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
+static usbd_device* usb_dev;
+static osSemaphoreId_t hid_u2f_semaphore = NULL;
+static bool hid_u2f_connected = false;
+
+static HidU2fCallback callback;
+static void* cb_ctx;
+
+bool furi_hal_hid_u2f_is_connected() {
+    return hid_u2f_connected;
+}
+
+void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx) {
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+
+    callback = cb;
+    cb_ctx = ctx;
+
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fConnected, cb_ctx);
+    }
+}
+
+UsbInterface usb_hid_u2f = {
+    .init = hid_u2f_init,
+    .deinit = hid_u2f_deinit,
+    .wakeup = hid_u2f_on_wakeup,
+    .suspend = hid_u2f_on_suspend,
+
+    .dev_descr = (struct usb_device_descriptor*)&hid_u2f_device_desc,
+
+    .str_manuf_descr = (void*)&dev_manuf_desc,
+    .str_prod_descr = (void*)&dev_prod_desc,
+    .str_serial_descr = (void*)&dev_serial_desc,
+
+    .cfg_descr = (void*)&hid_u2f_cfg_desc,
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf) {
+    if(hid_u2f_semaphore == NULL) hid_u2f_semaphore = osSemaphoreNew(1, 1, NULL);
+    usb_dev = dev;
+
+    usbd_reg_config(dev, hid_u2f_ep_config);
+    usbd_reg_control(dev, hid_u2f_control);
+
+    usbd_connect(dev, true);
+}
+
+static void hid_u2f_deinit(usbd_device* dev) {
+    usbd_reg_config(dev, NULL);
+    usbd_reg_control(dev, NULL);
+}
+
+static void hid_u2f_on_wakeup(usbd_device* dev) {
+    hid_u2f_connected = true;
+    if (callback != NULL)
+        callback(HidU2fConnected, cb_ctx);
+}
+
+static void hid_u2f_on_suspend(usbd_device* dev) {
+    if(hid_u2f_connected == true) {
+        hid_u2f_connected = false;
+        osSemaphoreRelease(hid_u2f_semaphore);
+        if (callback != NULL)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+}
+
+void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len) {
+    if ((hid_u2f_semaphore == NULL) || (hid_u2f_connected == false))
+        return;
+    furi_check(osSemaphoreAcquire(hid_u2f_semaphore, osWaitForever) == osOK);
+    if (hid_u2f_connected == true) {
+        usbd_ep_write(usb_dev, HID_EP_OUT, data, len);
+    }
+}
+
+uint32_t furi_hal_hid_u2f_get_request(uint8_t* data) {
+    int32_t len = usbd_ep_read(usb_dev, HID_EP_IN, data, HID_U2F_PACKET_LEN);
+    return ((len < 0) ? 0 : len);
+}
+
+static void hid_u2f_rx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (callback != NULL)
+        callback(HidU2fRequest, cb_ctx);
+}
+
+static void hid_u2f_tx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    osSemaphoreRelease(hid_u2f_semaphore);
+}
+
+static void hid_u2f_txrx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (event == usbd_evt_eptx) {
+        hid_u2f_tx_ep_callback(dev, event, ep);
+    } else {
+        hid_u2f_rx_ep_callback(dev, event, ep);
+    }
+}
+
+/* Configure endpoints */
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg) {
+    switch(cfg) {
+    case 0:
+        /* deconfiguring device */
+        usbd_ep_deconfig(dev, HID_EP_IN);
+        usbd_ep_deconfig(dev, HID_EP_OUT);
+        usbd_reg_endpoint(dev, HID_EP_IN, 0);
+        usbd_reg_endpoint(dev, HID_EP_OUT, 0);
+        return usbd_ack;
+    case 1:
+        /* configuring device */
+        usbd_ep_config(dev, HID_EP_IN, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_ep_config(dev, HID_EP_OUT, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_reg_endpoint(dev, HID_EP_IN, hid_u2f_txrx_ep_callback);
+        usbd_reg_endpoint(dev, HID_EP_OUT, hid_u2f_txrx_ep_callback);
+        usbd_ep_write(dev, HID_U2F_PACKET_LEN, 0, 0);
+        return usbd_ack;
+    default:
+        return usbd_fail;
+    }
+}
+
+/* Control requests handler */
+static usbd_respond hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
+    /* HID control requests */
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_CLASS) &&
+       req->wIndex == 0) {
+        switch(req->bRequest) {
+        case USB_HID_SETIDLE:
+            return usbd_ack;
+        case USB_HID_GETREPORT:
+            // dev->status.data_ptr = &hid_u2f_report;
+            // dev->status.data_count = sizeof(hid_u2f_report);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_STANDARD) &&
+       req->wIndex == 0 && req->bRequest == USB_STD_GET_DESCRIPTOR) {
+        switch(req->wValue >> 8) {
+        case USB_DTYPE_HID:
+            dev->status.data_ptr = (uint8_t*)&(hid_u2f_cfg_desc.iad_0.hid_desc);
+            dev->status.data_count = sizeof(hid_u2f_cfg_desc.iad_0.hid_desc);
+            return usbd_ack;
+        case USB_DTYPE_HID_REPORT:
+            dev->status.data_ptr = (uint8_t*)hid_u2f_report_desc;
+            dev->status.data_count = sizeof(hid_u2f_report_desc);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    return usbd_fail;
+}
diff --git a/firmware/targets/f6/target.mk b/firmware/targets/f6/target.mk
index 3b9ada6c..e60e375e 100644
--- a/firmware/targets/f6/target.mk
+++ b/firmware/targets/f6/target.mk
@@ -71,7 +71,8 @@ C_SOURCES += \
 	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_tim.c \
 	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_usart.c \
 	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_lpuart.c \
-	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_utils.c
+	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_utils.c \
+	$(CUBE_DIR)/Drivers/STM32WBxx_HAL_Driver/Src/stm32wbxx_ll_rng.c
 
 # FreeRTOS
 CFLAGS += \
diff --git a/firmware/targets/f7/furi-hal/furi-hal-crypto.c b/firmware/targets/f7/furi-hal/furi-hal-crypto.c
index 91875d23..f5398421 100644
--- a/firmware/targets/f7/furi-hal/furi-hal-crypto.c
+++ b/firmware/targets/f7/furi-hal/furi-hal-crypto.c
@@ -1,5 +1,6 @@
 #include <furi-hal-crypto.h>
 #include <furi-hal-bt.h>
+#include <furi-hal-random.h>
 #include <furi.h>
 #include <shci.h>
 
@@ -7,10 +8,119 @@
 
 CRYP_HandleTypeDef crypt;
 
+#define ENCLAVE_FACTORY_KEY_SLOTS 10
+#define ENCLAVE_SIGNATURE_SIZE 16
+
+static const uint8_t enclave_signature_iv[ENCLAVE_FACTORY_KEY_SLOTS][16] = {
+    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
+    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
+    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
+    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
+    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
+    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
+    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
+    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
+    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
+    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
+};
+
+static const uint8_t enclave_signature_input[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
+    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
+    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
+    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
+    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
+    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
+    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
+    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
+    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
+    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
+};
+
+static const uint8_t enclave_signature_expected[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
+    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
+    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
+    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
+    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
+    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
+    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
+    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
+    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
+    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
+    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
+};
+
 void furi_hal_crypto_init() {
     FURI_LOG_I(TAG, "Init OK");
 }
 
+static bool furi_hal_crypto_generate_unique_keys(uint8_t start_slot, uint8_t end_slot) {
+    FuriHalCryptoKey key;
+    uint8_t key_data[32];
+    FURI_LOG_I(TAG, "Generating keys %u..%u", start_slot, end_slot);
+    for (uint8_t slot = start_slot; slot <= end_slot; slot++) {
+        key.type = FuriHalCryptoKeyTypeSimple;
+        key.size = FuriHalCryptoKeySize256;
+        key.data = key_data;
+        furi_hal_random_fill_buf(key_data, 32);
+        if (!furi_hal_crypto_store_add_key(&key, &slot)) {
+            FURI_LOG_E(TAG, "Error writing key to slot %u", slot);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_key(uint8_t key_slot) {
+    uint8_t keys_nb = 0;
+    uint8_t valid_keys_nb = 0;
+    uint8_t last_valid_slot = ENCLAVE_FACTORY_KEY_SLOTS;
+    uint8_t empty_iv[16];
+    furi_hal_crypto_verify_enclave(&keys_nb, &valid_keys_nb);
+    if (key_slot <= ENCLAVE_FACTORY_KEY_SLOTS) { // It's a factory key
+        if (key_slot > keys_nb)
+            return false;
+    } else { // Unique key
+        if (keys_nb < ENCLAVE_FACTORY_KEY_SLOTS) // Some factory keys are missing
+            return false;
+        for (uint8_t i = key_slot; i > ENCLAVE_FACTORY_KEY_SLOTS; i--) {
+            if(furi_hal_crypto_store_load_key(i, empty_iv)) {
+                last_valid_slot = i;
+                furi_hal_crypto_store_unload_key(i);
+                break;
+            }
+        }
+        if (last_valid_slot == key_slot)
+            return true;
+        else // Generate missing unique keys
+            return furi_hal_crypto_generate_unique_keys(last_valid_slot+1, key_slot);
+    }
+    return true;
+}
+
+bool furi_hal_crypto_verify_enclave(uint8_t* keys_nb, uint8_t* valid_keys_nb) {
+    furi_assert(keys_nb);
+    furi_assert(valid_keys_nb);
+    uint8_t keys = 0;
+    uint8_t keys_valid = 0;
+    uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
+    for(size_t key_slot = 0; key_slot < ENCLAVE_FACTORY_KEY_SLOTS; key_slot++) {
+        if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
+            keys++;
+            if(furi_hal_crypto_encrypt(enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
+                keys_valid += memcmp(buffer, enclave_signature_expected[key_slot], ENCLAVE_SIGNATURE_SIZE) == 0;
+            }
+            furi_hal_crypto_store_unload_key(key_slot + 1);
+        }
+    }
+    *keys_nb = keys;
+    *valid_keys_nb = keys_valid;
+    if (*valid_keys_nb == ENCLAVE_FACTORY_KEY_SLOTS)
+        return true;
+    else
+        return false;
+}
+
 bool furi_hal_crypto_store_add_key(FuriHalCryptoKey* key, uint8_t* slot) {
     furi_assert(key);
     furi_assert(slot);
diff --git a/firmware/targets/f7/furi-hal/furi-hal-info.c b/firmware/targets/f7/furi-hal/furi-hal-info.c
index 783a5113..c1225ac9 100644
--- a/firmware/targets/f7/furi-hal/furi-hal-info.c
+++ b/firmware/targets/f7/furi-hal/furi-hal-info.c
@@ -2,48 +2,6 @@
 #include <furi-hal.h>
 #include <shci.h>
 
-#define ENCLAVE_SIGNATURE_KEY_SLOTS 10
-#define ENCLAVE_SIGNATURE_SIZE 16
-
-static const uint8_t enclave_signature_iv[ENCLAVE_SIGNATURE_KEY_SLOTS][16] = {
-    {0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
-    {0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
-    {0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
-    {0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
-    {0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
-    {0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
-    {0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
-    {0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
-    {0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
-    {0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
-};
-
-static const uint8_t enclave_signature_input[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
-    {0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
-    {0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
-    {0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
-    {0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
-    {0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
-    {0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
-    {0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
-    {0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
-    {0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
-};
-
-static const uint8_t enclave_signature_expected[ENCLAVE_SIGNATURE_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
-    {0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
-    {0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
-    {0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
-    {0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
-    {0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
-    {0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
-    {0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
-    {0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
-    {0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
-    {0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
-};
-
 void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
     string_t value;
     string_init(value);
@@ -164,23 +122,12 @@ void furi_hal_info_get(FuriHalInfoValueCallback out, void* context) {
         out("radio_ble_mac", string_get_cstr(value), false, context);
 
         // Signature verification
-        uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
-        size_t enclave_valid_keys = 0;
-        for(size_t key_slot = 0; key_slot < ENCLAVE_SIGNATURE_KEY_SLOTS; key_slot++) {
-            if(furi_hal_crypto_store_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
-                if(furi_hal_crypto_encrypt(
-                       enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
-                    enclave_valid_keys += memcmp(
-                                              buffer,
-                                              enclave_signature_expected[key_slot],
-                                              ENCLAVE_SIGNATURE_SIZE) == 0;
-                }
-                furi_hal_crypto_store_unload_key(key_slot + 1);
-            }
-        }
+        uint8_t enclave_keys = 0;
+        uint8_t enclave_valid_keys = 0;
+        bool enclave_valid = furi_hal_crypto_verify_enclave(&enclave_keys, &enclave_valid_keys);
         string_printf(value, "%d", enclave_valid_keys);
         out("enclave_valid_keys", string_get_cstr(value), false, context);
-        out("enclave_valid", (enclave_valid_keys == ENCLAVE_SIGNATURE_KEY_SLOTS) ? "true" : "false", true, context);
+        out("enclave_valid", enclave_valid ? "true" : "false", true, context);
     } else {
         out("radio_alive", "false", true, context);
     }
diff --git a/firmware/targets/f7/furi-hal/furi-hal-random.c b/firmware/targets/f7/furi-hal/furi-hal-random.c
new file mode 100644
index 00000000..a7bc3a31
--- /dev/null
+++ b/firmware/targets/f7/furi-hal/furi-hal-random.c
@@ -0,0 +1,56 @@
+#include "furi-hal-random.h"
+#include <furi.h>
+#include <furi-hal.h>
+
+#include <stm32wbxx_ll_rng.h>
+#include <stm32wbxx_ll_hsem.h>
+
+#include <hw_conf.h>
+
+uint32_t furi_hal_random_get() {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+    if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+        furi_crash("TRNG error");
+    }
+
+    uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+
+    return random_val;
+}
+
+void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len) {
+
+    while( LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID));
+    LL_RNG_Enable(RNG);
+
+    for (uint32_t i = 0; i < len; i+= 4) {
+        while (!LL_RNG_IsActiveFlag_DRDY(RNG));
+
+        if ((LL_RNG_IsActiveFlag_CECS(RNG)) || (LL_RNG_IsActiveFlag_SECS(RNG))) {
+            furi_crash("TRNG error");
+        }
+
+        uint32_t random_val = LL_RNG_ReadRandData32(RNG);
+
+        uint8_t len_cur = ((i+4) < len) ? (4) : (len-i);
+        memcpy(&buf[i], &random_val, len_cur);
+    }
+
+    LL_RNG_Disable(RNG);
+    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
+}
+
+void srand(unsigned seed) {
+}
+
+int rand() {
+    return (furi_hal_random_get() & RAND_MAX);
+}
diff --git a/firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c b/firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c
new file mode 100644
index 00000000..a7426c82
--- /dev/null
+++ b/firmware/targets/f7/furi-hal/furi-hal-usb-u2f.c
@@ -0,0 +1,309 @@
+#include "furi-hal-version.h"
+#include "furi-hal-usb_i.h"
+#include "furi-hal-usb-hid-u2f.h"
+#include "furi-hal-usb.h"
+#include <furi.h>
+#include "usb.h"
+#include "usb_hid.h"
+
+#define HID_PAGE_FIDO 0xF1D0
+#define HID_FIDO_U2F 0x01
+#define HID_FIDO_INPUT 0x20
+#define HID_FIDO_OUTPUT 0x21
+
+#define HID_EP_IN 0x81
+#define HID_EP_OUT 0x01
+
+struct HidIadDescriptor {
+    struct usb_iad_descriptor hid_iad;
+    struct usb_interface_descriptor hid;
+    struct usb_hid_descriptor hid_desc;
+    struct usb_endpoint_descriptor hid_ep_in;
+    struct usb_endpoint_descriptor hid_ep_out;
+};
+
+struct HidConfigDescriptor {
+    struct usb_config_descriptor config;
+    struct HidIadDescriptor iad_0;
+} __attribute__((packed));
+
+/* HID report: FIDO U2F */
+static const uint8_t hid_u2f_report_desc[] = {
+    HID_RI_USAGE_PAGE(16, HID_PAGE_FIDO),
+    HID_USAGE(HID_FIDO_U2F),
+    HID_COLLECTION(HID_APPLICATION_COLLECTION),
+    HID_USAGE(HID_FIDO_INPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_USAGE(HID_FIDO_OUTPUT),
+    HID_LOGICAL_MINIMUM(0x00),
+    HID_LOGICAL_MAXIMUM(0xFF),
+    HID_REPORT_SIZE(8),
+    HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
+    HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
+    HID_END_COLLECTION,
+};
+
+static const struct usb_string_descriptor dev_manuf_desc = USB_STRING_DESC("Flipper Devices Inc.");
+static const struct usb_string_descriptor dev_prod_desc = USB_STRING_DESC("U2F Token test");
+static const struct usb_string_descriptor dev_serial_desc = USB_STRING_DESC("TODO: serial");
+
+/* Device descriptor */
+static const struct usb_device_descriptor hid_u2f_device_desc = {
+    .bLength = sizeof(struct usb_device_descriptor),
+    .bDescriptorType = USB_DTYPE_DEVICE,
+    .bcdUSB = VERSION_BCD(2, 0, 0),
+    .bDeviceClass = USB_CLASS_IAD,
+    .bDeviceSubClass = USB_SUBCLASS_IAD,
+    .bDeviceProtocol = USB_PROTO_IAD,
+    .bMaxPacketSize0 = USB_EP0_SIZE,
+    .idVendor = 0x0483,
+    .idProduct = 0x5741,
+    .bcdDevice = VERSION_BCD(1, 0, 0),
+    .iManufacturer = UsbDevManuf,
+    .iProduct = UsbDevProduct,
+    .iSerialNumber = UsbDevSerial,
+    .bNumConfigurations = 1,
+};
+
+/* Device configuration descriptor */
+static const struct HidConfigDescriptor hid_u2f_cfg_desc = {
+    .config =
+        {
+            .bLength = sizeof(struct usb_config_descriptor),
+            .bDescriptorType = USB_DTYPE_CONFIGURATION,
+            .wTotalLength = sizeof(struct HidConfigDescriptor),
+            .bNumInterfaces = 1,
+            .bConfigurationValue = 1,
+            .iConfiguration = NO_DESCRIPTOR,
+            .bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
+            .bMaxPower = USB_CFG_POWER_MA(100),
+        },
+    .iad_0 =
+        {
+            .hid_iad =
+                {
+                    .bLength = sizeof(struct usb_iad_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFASEASSOC,
+                    .bFirstInterface = 0,
+                    .bInterfaceCount = 1,
+                    .bFunctionClass = USB_CLASS_PER_INTERFACE,
+                    .bFunctionSubClass = USB_SUBCLASS_NONE,
+                    .bFunctionProtocol = USB_PROTO_NONE,
+                    .iFunction = NO_DESCRIPTOR,
+                },
+            .hid =
+                {
+                    .bLength = sizeof(struct usb_interface_descriptor),
+                    .bDescriptorType = USB_DTYPE_INTERFACE,
+                    .bInterfaceNumber = 0,
+                    .bAlternateSetting = 0,
+                    .bNumEndpoints = 2,
+                    .bInterfaceClass = USB_CLASS_HID,
+                    .bInterfaceSubClass = USB_HID_SUBCLASS_NONBOOT,
+                    .bInterfaceProtocol = USB_HID_PROTO_NONBOOT,
+                    .iInterface = NO_DESCRIPTOR,
+                },
+            .hid_desc =
+                {
+                    .bLength = sizeof(struct usb_hid_descriptor),
+                    .bDescriptorType = USB_DTYPE_HID,
+                    .bcdHID = VERSION_BCD(1, 0, 0),
+                    .bCountryCode = USB_HID_COUNTRY_NONE,
+                    .bNumDescriptors = 1,
+                    .bDescriptorType0 = USB_DTYPE_HID_REPORT,
+                    .wDescriptorLength0 = sizeof(hid_u2f_report_desc),
+                },
+            .hid_ep_in =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_IN,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+            .hid_ep_out =
+                {
+                    .bLength = sizeof(struct usb_endpoint_descriptor),
+                    .bDescriptorType = USB_DTYPE_ENDPOINT,
+                    .bEndpointAddress = HID_EP_OUT,
+                    .bmAttributes = USB_EPTYPE_INTERRUPT,
+                    .wMaxPacketSize = HID_U2F_PACKET_LEN,
+                    .bInterval = 5,
+                },
+        },
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf);
+static void hid_u2f_deinit(usbd_device* dev);
+static void hid_u2f_on_wakeup(usbd_device* dev);
+static void hid_u2f_on_suspend(usbd_device* dev);
+
+//static bool hid_u2f_send_report(uint8_t report_id);
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg);
+static usbd_respond
+    hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
+static usbd_device* usb_dev;
+static osSemaphoreId_t hid_u2f_semaphore = NULL;
+static bool hid_u2f_connected = false;
+
+static HidU2fCallback callback;
+static void* cb_ctx;
+
+bool furi_hal_hid_u2f_is_connected() {
+    return hid_u2f_connected;
+}
+
+void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx) {
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+
+    callback = cb;
+    cb_ctx = ctx;
+
+    if (callback != NULL) {
+        if (hid_u2f_connected == true)
+            callback(HidU2fConnected, cb_ctx);
+    }
+}
+
+UsbInterface usb_hid_u2f = {
+    .init = hid_u2f_init,
+    .deinit = hid_u2f_deinit,
+    .wakeup = hid_u2f_on_wakeup,
+    .suspend = hid_u2f_on_suspend,
+
+    .dev_descr = (struct usb_device_descriptor*)&hid_u2f_device_desc,
+
+    .str_manuf_descr = (void*)&dev_manuf_desc,
+    .str_prod_descr = (void*)&dev_prod_desc,
+    .str_serial_descr = (void*)&dev_serial_desc,
+
+    .cfg_descr = (void*)&hid_u2f_cfg_desc,
+};
+
+static void hid_u2f_init(usbd_device* dev, UsbInterface* intf) {
+    if(hid_u2f_semaphore == NULL) hid_u2f_semaphore = osSemaphoreNew(1, 1, NULL);
+    usb_dev = dev;
+
+    usbd_reg_config(dev, hid_u2f_ep_config);
+    usbd_reg_control(dev, hid_u2f_control);
+
+    usbd_connect(dev, true);
+}
+
+static void hid_u2f_deinit(usbd_device* dev) {
+    usbd_reg_config(dev, NULL);
+    usbd_reg_control(dev, NULL);
+}
+
+static void hid_u2f_on_wakeup(usbd_device* dev) {
+    hid_u2f_connected = true;
+    if (callback != NULL)
+        callback(HidU2fConnected, cb_ctx);
+}
+
+static void hid_u2f_on_suspend(usbd_device* dev) {
+    if(hid_u2f_connected == true) {
+        hid_u2f_connected = false;
+        osSemaphoreRelease(hid_u2f_semaphore);
+        if (callback != NULL)
+            callback(HidU2fDisconnected, cb_ctx);
+    }
+}
+
+void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len) {
+    if ((hid_u2f_semaphore == NULL) || (hid_u2f_connected == false))
+        return;
+    furi_check(osSemaphoreAcquire(hid_u2f_semaphore, osWaitForever) == osOK);
+    if (hid_u2f_connected == true) {
+        usbd_ep_write(usb_dev, HID_EP_OUT, data, len);
+    }
+}
+
+uint32_t furi_hal_hid_u2f_get_request(uint8_t* data) {
+    int32_t len = usbd_ep_read(usb_dev, HID_EP_IN, data, HID_U2F_PACKET_LEN);
+    return ((len < 0) ? 0 : len);
+}
+
+static void hid_u2f_rx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (callback != NULL)
+        callback(HidU2fRequest, cb_ctx);
+}
+
+static void hid_u2f_tx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    osSemaphoreRelease(hid_u2f_semaphore);
+}
+
+static void hid_u2f_txrx_ep_callback (usbd_device *dev, uint8_t event, uint8_t ep) {
+    if (event == usbd_evt_eptx) {
+        hid_u2f_tx_ep_callback(dev, event, ep);
+    } else {
+        hid_u2f_rx_ep_callback(dev, event, ep);
+    }
+}
+
+/* Configure endpoints */
+static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg) {
+    switch(cfg) {
+    case 0:
+        /* deconfiguring device */
+        usbd_ep_deconfig(dev, HID_EP_IN);
+        usbd_ep_deconfig(dev, HID_EP_OUT);
+        usbd_reg_endpoint(dev, HID_EP_IN, 0);
+        usbd_reg_endpoint(dev, HID_EP_OUT, 0);
+        return usbd_ack;
+    case 1:
+        /* configuring device */
+        usbd_ep_config(dev, HID_EP_IN, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_ep_config(dev, HID_EP_OUT, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
+        usbd_reg_endpoint(dev, HID_EP_IN, hid_u2f_txrx_ep_callback);
+        usbd_reg_endpoint(dev, HID_EP_OUT, hid_u2f_txrx_ep_callback);
+        usbd_ep_write(dev, HID_U2F_PACKET_LEN, 0, 0);
+        return usbd_ack;
+    default:
+        return usbd_fail;
+    }
+}
+
+/* Control requests handler */
+static usbd_respond hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
+    /* HID control requests */
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_CLASS) &&
+       req->wIndex == 0) {
+        switch(req->bRequest) {
+        case USB_HID_SETIDLE:
+            return usbd_ack;
+        case USB_HID_GETREPORT:
+            // dev->status.data_ptr = &hid_u2f_report;
+            // dev->status.data_count = sizeof(hid_u2f_report);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    if (((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
+           (USB_REQ_INTERFACE | USB_REQ_STANDARD) &&
+       req->wIndex == 0 && req->bRequest == USB_STD_GET_DESCRIPTOR) {
+        switch(req->wValue >> 8) {
+        case USB_DTYPE_HID:
+            dev->status.data_ptr = (uint8_t*)&(hid_u2f_cfg_desc.iad_0.hid_desc);
+            dev->status.data_count = sizeof(hid_u2f_cfg_desc.iad_0.hid_desc);
+            return usbd_ack;
+        case USB_DTYPE_HID_REPORT:
+            dev->status.data_ptr = (uint8_t*)hid_u2f_report_desc;
+            dev->status.data_count = sizeof(hid_u2f_report_desc);
+            return usbd_ack;
+        default:
+            return usbd_fail;
+        }
+    }
+    return usbd_fail;
+}
diff --git a/firmware/targets/furi-hal-include/furi-hal-crypto.h b/firmware/targets/furi-hal-include/furi-hal-crypto.h
index 482b3d7a..3aba2ede 100644
--- a/firmware/targets/furi-hal-include/furi-hal-crypto.h
+++ b/firmware/targets/furi-hal-include/furi-hal-crypto.h
@@ -32,6 +32,10 @@ typedef struct {
  */
 void furi_hal_crypto_init();
 
+bool furi_hal_crypto_verify_enclave(uint8_t* keys_nb, uint8_t* valid_keys_nb);
+
+bool furi_hal_crypto_verify_key(uint8_t key_slot);
+
 /** Store key in crypto storage
  *
  * @param      key   FuriHalCryptoKey to store. Only Master, Simple or
diff --git a/firmware/targets/furi-hal-include/furi-hal-random.h b/firmware/targets/furi-hal-include/furi-hal-random.h
new file mode 100644
index 00000000..fa549d23
--- /dev/null
+++ b/firmware/targets/furi-hal-include/furi-hal-random.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Get random value
+ *
+ * @return     random value
+ */
+uint32_t furi_hal_random_get();
+
+/** Fill buffer with random data
+ *
+ * @param      buf  buffer pointer
+ * @param      data buffer len
+ */
+void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h b/firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h
new file mode 100644
index 00000000..e9bf5765
--- /dev/null
+++ b/firmware/targets/furi-hal-include/furi-hal-usb-hid-u2f.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#define HID_U2F_PACKET_LEN 64
+
+typedef enum {
+    HidU2fDisconnected,
+    HidU2fConnected,
+    HidU2fRequest,
+} HidU2fEvent;
+
+typedef void (*HidU2fCallback)(HidU2fEvent ev, void* context);
+
+/** Get HID U2F connection state
+ *
+ * @return      true / false
+ */
+bool furi_hal_hid_u2f_is_connected();
+
+/** Set HID U2F event callback
+ *
+ * @param      cb  callback
+ * @param      ctx  callback context
+ */
+void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx);
+
+/** Get received U2F HID packet
+ *
+ */
+uint32_t furi_hal_hid_u2f_get_request(uint8_t* data);
+
+/** Send U2F HID response packet
+ *
+ * @param      data  response data
+ * @param      len  packet length
+ */
+void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len);
diff --git a/firmware/targets/furi-hal-include/furi-hal-usb.h b/firmware/targets/furi-hal-include/furi-hal-usb.h
index b11ddcf1..a384236b 100644
--- a/firmware/targets/furi-hal-include/furi-hal-usb.h
+++ b/firmware/targets/furi-hal-include/furi-hal-usb.h
@@ -23,6 +23,7 @@ struct UsbInterface {
 extern UsbInterface usb_cdc_single;
 extern UsbInterface usb_cdc_dual;
 extern UsbInterface usb_hid;
+extern UsbInterface usb_hid_u2f;
 
 /** USB device low-level initialization
  */
diff --git a/firmware/targets/furi-hal-include/furi-hal.h b/firmware/targets/furi-hal-include/furi-hal.h
index f7613625..e0885598 100644
--- a/firmware/targets/furi-hal-include/furi-hal.h
+++ b/firmware/targets/furi-hal-include/furi-hal.h
@@ -40,6 +40,7 @@ template <unsigned int N> struct STOP_EXTERNING_ME {};
 #include "furi-hal-compress.h"
 #include "furi-hal-uart.h"
 #include "furi-hal-info.h"
+#include "furi-hal-random.h"
 
 /** Init furi-hal */
 void furi_hal_init();
diff --git a/lib/lib.mk b/lib/lib.mk
index 98ae0d5f..23db841c 100644
--- a/lib/lib.mk
+++ b/lib/lib.mk
@@ -124,3 +124,7 @@ C_SOURCES		+= $(wildcard $(LIB_DIR)/heatshrink/*.c)
 # Toolbox
 CFLAGS			+= -I$(LIB_DIR)/flipper_file
 C_SOURCES		+= $(wildcard $(LIB_DIR)/flipper_file/*.c)
+
+# Micro-ECC
+CFLAGS			+= -I$(LIB_DIR)/micro-ecc
+C_SOURCES		+= $(wildcard $(LIB_DIR)/micro-ecc/*.c)
diff --git a/lib/micro-ecc/LICENSE.txt b/lib/micro-ecc/LICENSE.txt
new file mode 100644
index 00000000..ab099ae5
--- /dev/null
+++ b/lib/micro-ecc/LICENSE.txt
@@ -0,0 +1,21 @@
+Copyright (c) 2014, Kenneth MacKay
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/micro-ecc/README.md b/lib/micro-ecc/README.md
new file mode 100644
index 00000000..111321bf
--- /dev/null
+++ b/lib/micro-ecc/README.md
@@ -0,0 +1,41 @@
+micro-ecc
+==========
+
+A small and fast ECDH and ECDSA implementation for 8-bit, 32-bit, and 64-bit processors.
+
+The static version of micro-ecc (ie, where the curve was selected at compile-time) can be found in the "static" branch.
+
+Features
+--------
+
+ * Resistant to known side-channel attacks.
+ * Written in C, with optional GCC inline assembly for AVR, ARM and Thumb platforms.
+ * Supports 8, 32, and 64-bit architectures.
+ * Small code size.
+ * No dynamic memory allocation.
+ * Support for 5 standard curves: secp160r1, secp192r1, secp224r1, secp256r1, and secp256k1.
+ * BSD 2-clause license.
+
+Usage Notes
+-----------
+### Point Representation ###
+Compressed points are represented in the standard format as defined in http://www.secg.org/sec1-v2.pdf; uncompressed points are represented in standard format, but without the `0x04` prefix. All functions except `uECC_decompress()` only accept uncompressed points; use `uECC_compress()` and `uECC_decompress()` to convert between compressed and uncompressed point representations.
+
+Private keys are represented in the standard format.
+
+### Using the Code ###
+
+I recommend just copying (or symlink) the uECC files into your project. Then just `#include "uECC.h"` to use the micro-ecc functions.
+
+For use with Arduino, you can use the Library Manager to download micro-ecc (**Sketch**=>**Include Library**=>**Manage Libraries**). You can then use uECC just like any other Arduino library (uECC should show up in the **Sketch**=>**Import Library** submenu).
+
+See uECC.h for documentation for each function.
+
+### Compilation Notes ###
+
+ * Should compile with any C/C++ compiler that supports stdint.h (this includes Visual Studio 2013).
+ * If you want to change the defaults for any of the uECC compile-time options (such as `uECC_OPTIMIZATION_LEVEL`), you must change them in your Makefile or similar so that uECC.c is compiled with the desired values (ie, compile uECC.c with `-DuECC_OPTIMIZATION_LEVEL=3` or whatever).
+ * When compiling for a Thumb-1 platform, you must use the `-fomit-frame-pointer` GCC option (this is enabled by default when compiling with `-O1` or higher).
+ * When compiling for an ARM/Thumb-2 platform with `uECC_OPTIMIZATION_LEVEL` >= 3, you must use the `-fomit-frame-pointer` GCC option (this is enabled by default when compiling with `-O1` or higher).
+ * When compiling for AVR, you must have optimizations enabled (compile with `-O1` or higher).
+ * When building for Windows, you will need to link in the `advapi32.lib` system library.
diff --git a/lib/micro-ecc/asm_arm.inc b/lib/micro-ecc/asm_arm.inc
new file mode 100644
index 00000000..688fdc75
--- /dev/null
+++ b/lib/micro-ecc/asm_arm.inc
@@ -0,0 +1,820 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_ASM_ARM_H_
+#define _UECC_ASM_ARM_H_
+
+#if (uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1)
+    #define uECC_MIN_WORDS 8
+#endif
+#if uECC_SUPPORTS_secp224r1
+    #undef uECC_MIN_WORDS
+    #define uECC_MIN_WORDS 7
+#endif
+#if uECC_SUPPORTS_secp192r1
+    #undef uECC_MIN_WORDS
+    #define uECC_MIN_WORDS 6
+#endif
+#if uECC_SUPPORTS_secp160r1
+    #undef uECC_MIN_WORDS
+    #define uECC_MIN_WORDS 5
+#endif
+
+#if (uECC_PLATFORM == uECC_arm_thumb)
+    #define REG_RW "+l"
+    #define REG_WRITE "=l"
+#else
+    #define REG_RW "+r"
+    #define REG_WRITE "=r"
+#endif
+
+#if (uECC_PLATFORM == uECC_arm_thumb || uECC_PLATFORM == uECC_arm_thumb2)
+    #define REG_RW_LO "+l"
+    #define REG_WRITE_LO "=l"
+#else
+    #define REG_RW_LO "+r"
+    #define REG_WRITE_LO "=r"
+#endif
+
+#if (uECC_PLATFORM == uECC_arm_thumb2)
+    #define RESUME_SYNTAX
+#else
+    #define RESUME_SYNTAX ".syntax divided \n\t"
+#endif
+
+#if (uECC_OPTIMIZATION_LEVEL >= 2)
+
+uECC_VLI_API uECC_word_t uECC_vli_add(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+#if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+  #if (uECC_PLATFORM == uECC_arm_thumb) || (uECC_PLATFORM == uECC_arm_thumb2)
+    uint32_t jump = (uECC_MAX_WORDS - num_words) * 4 * 2 + 1;
+  #else /* ARM */
+    uint32_t jump = (uECC_MAX_WORDS - num_words) * 4 * 4;
+  #endif
+#endif
+    uint32_t carry;
+    uint32_t left_word;
+    uint32_t right_word;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        "movs %[carry], #0 \n\t"
+    #if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+        "adr %[left], 1f \n\t"
+        ".align 4 \n\t"
+        "adds %[jump], %[left] \n\t"
+    #endif
+        
+        "ldmia %[lptr]!, {%[left]} \n\t"
+        "ldmia %[rptr]!, {%[right]} \n\t"
+        "adds %[left], %[right] \n\t"
+        "stmia %[dptr]!, {%[left]} \n\t"
+        
+    #if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+        "bx %[jump] \n\t"
+    #endif
+        "1: \n\t"
+        REPEAT(DEC(uECC_MAX_WORDS),
+            "ldmia %[lptr]!, {%[left]} \n\t"
+            "ldmia %[rptr]!, {%[right]} \n\t"
+            "adcs %[left], %[right] \n\t"
+            "stmia %[dptr]!, {%[left]} \n\t")
+        
+        "adcs %[carry], %[carry] \n\t"
+        RESUME_SYNTAX
+        : [dptr] REG_RW_LO (result), [lptr] REG_RW_LO (left), [rptr] REG_RW_LO (right),
+    #if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+          [jump] REG_RW_LO (jump),
+    #endif
+          [carry] REG_WRITE_LO (carry), [left] REG_WRITE_LO (left_word),
+          [right] REG_WRITE_LO (right_word)
+        :
+        : "cc", "memory"
+    );
+    return carry;
+}
+#define asm_add 1
+
+uECC_VLI_API uECC_word_t uECC_vli_sub(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+#if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+  #if (uECC_PLATFORM == uECC_arm_thumb) || (uECC_PLATFORM == uECC_arm_thumb2)
+    uint32_t jump = (uECC_MAX_WORDS - num_words) * 4 * 2 + 1;
+  #else /* ARM */
+    uint32_t jump = (uECC_MAX_WORDS - num_words) * 4 * 4;
+  #endif
+#endif
+    uint32_t carry;
+    uint32_t left_word;
+    uint32_t right_word;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        "movs %[carry], #0 \n\t"
+    #if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+        "adr %[left], 1f \n\t"
+        ".align 4 \n\t"
+        "adds %[jump], %[left] \n\t"
+    #endif
+        
+        "ldmia %[lptr]!, {%[left]} \n\t"
+        "ldmia %[rptr]!, {%[right]} \n\t"
+        "subs %[left], %[right] \n\t"
+        "stmia %[dptr]!, {%[left]} \n\t"
+        
+    #if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+        "bx %[jump] \n\t"
+    #endif
+        "1: \n\t"
+        REPEAT(DEC(uECC_MAX_WORDS),
+            "ldmia %[lptr]!, {%[left]} \n\t"
+            "ldmia %[rptr]!, {%[right]} \n\t"
+            "sbcs %[left], %[right] \n\t"
+            "stmia %[dptr]!, {%[left]} \n\t")
+        
+        "adcs %[carry], %[carry] \n\t"
+        RESUME_SYNTAX
+        : [dptr] REG_RW_LO (result), [lptr] REG_RW_LO (left), [rptr] REG_RW_LO (right),
+    #if (uECC_MAX_WORDS != uECC_MIN_WORDS)
+          [jump] REG_RW_LO (jump),
+    #endif
+          [carry] REG_WRITE_LO (carry), [left] REG_WRITE_LO (left_word),
+          [right] REG_WRITE_LO (right_word)
+        :
+        : "cc", "memory"
+    );
+    return !carry; /* Note that on ARM, carry flag set means "no borrow" when subtracting
+                      (for some reason...) */
+}
+#define asm_sub 1
+
+#endif /* (uECC_OPTIMIZATION_LEVEL >= 2) */
+
+#if (uECC_OPTIMIZATION_LEVEL >= 3)
+
+#if (uECC_PLATFORM != uECC_arm_thumb)
+
+#if uECC_ARM_USE_UMAAL
+    #include "asm_arm_mult_square_umaal.inc"
+#else
+    #include "asm_arm_mult_square.inc"
+#endif
+
+#if (uECC_OPTIMIZATION_LEVEL == 3)
+
+uECC_VLI_API void uECC_vli_mult(uint32_t *result,
+                                const uint32_t *left,
+                                const uint32_t *right,
+                                wordcount_t num_words) {
+    register uint32_t *r0 __asm__("r0") = result;
+    register const uint32_t *r1 __asm__("r1") = left;
+    register const uint32_t *r2 __asm__("r2") = right;
+    register uint32_t r3 __asm__("r3") = num_words;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+#if (uECC_MIN_WORDS == 5)
+        FAST_MULT_ASM_5
+    #if (uECC_MAX_WORDS > 5)
+        FAST_MULT_ASM_5_TO_6
+    #endif
+    #if (uECC_MAX_WORDS > 6)
+        FAST_MULT_ASM_6_TO_7
+    #endif
+    #if (uECC_MAX_WORDS > 7)
+        FAST_MULT_ASM_7_TO_8
+    #endif
+#elif (uECC_MIN_WORDS == 6)
+        FAST_MULT_ASM_6
+    #if (uECC_MAX_WORDS > 6)
+        FAST_MULT_ASM_6_TO_7
+    #endif
+    #if (uECC_MAX_WORDS > 7)
+        FAST_MULT_ASM_7_TO_8
+    #endif
+#elif (uECC_MIN_WORDS == 7)
+        FAST_MULT_ASM_7
+    #if (uECC_MAX_WORDS > 7)
+        FAST_MULT_ASM_7_TO_8
+    #endif
+#elif (uECC_MIN_WORDS == 8)
+        FAST_MULT_ASM_8
+#endif
+        "1: \n\t"
+        RESUME_SYNTAX
+        : "+r" (r0), "+r" (r1), "+r" (r2)
+        : "r" (r3)
+        : "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+    );
+}
+#define asm_mult 1
+
+#if uECC_SQUARE_FUNC
+uECC_VLI_API void uECC_vli_square(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  wordcount_t num_words) {
+    register uint32_t *r0 __asm__("r0") = result;
+    register const uint32_t *r1 __asm__("r1") = left;
+    register uint32_t r2 __asm__("r2") = num_words;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+#if (uECC_MIN_WORDS == 5)
+        FAST_SQUARE_ASM_5
+    #if (uECC_MAX_WORDS > 5)
+        FAST_SQUARE_ASM_5_TO_6
+    #endif
+    #if (uECC_MAX_WORDS > 6)
+        FAST_SQUARE_ASM_6_TO_7
+    #endif
+    #if (uECC_MAX_WORDS > 7)
+        FAST_SQUARE_ASM_7_TO_8
+    #endif
+#elif (uECC_MIN_WORDS == 6)
+        FAST_SQUARE_ASM_6
+    #if (uECC_MAX_WORDS > 6)
+        FAST_SQUARE_ASM_6_TO_7
+    #endif
+    #if (uECC_MAX_WORDS > 7)
+        FAST_SQUARE_ASM_7_TO_8
+    #endif
+#elif (uECC_MIN_WORDS == 7)
+        FAST_SQUARE_ASM_7
+    #if (uECC_MAX_WORDS > 7)
+        FAST_SQUARE_ASM_7_TO_8
+    #endif
+#elif (uECC_MIN_WORDS == 8)
+        FAST_SQUARE_ASM_8
+#endif
+
+        "1: \n\t"
+        RESUME_SYNTAX
+        : "+r" (r0), "+r" (r1)
+        : "r" (r2)
+        : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+    );
+}
+#define asm_square 1
+#endif /* uECC_SQUARE_FUNC */
+
+#else /* (uECC_OPTIMIZATION_LEVEL > 3) */
+
+uECC_VLI_API void uECC_vli_mult(uint32_t *result,
+                                const uint32_t *left,
+                                const uint32_t *right,
+                                wordcount_t num_words) {
+    register uint32_t *r0 __asm__("r0") = result;
+    register const uint32_t *r1 __asm__("r1") = left;
+    register const uint32_t *r2 __asm__("r2") = right;
+    register uint32_t r3 __asm__("r3") = num_words;
+    
+#if uECC_SUPPORTS_secp160r1
+    if (num_words == 5) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_MULT_ASM_5
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1), "+r" (r2)
+            : "r" (r3)
+            : "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+#if uECC_SUPPORTS_secp192r1
+    if (num_words == 6) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_MULT_ASM_6
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1), "+r" (r2)
+            : "r" (r3)
+            : "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+#if uECC_SUPPORTS_secp224r1
+    if (num_words == 7) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_MULT_ASM_7
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1), "+r" (r2)
+            : "r" (r3)
+            : "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+#if (uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1)
+    if (num_words == 8) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_MULT_ASM_8
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1), "+r" (r2)
+            : "r" (r3)
+            : "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+}
+#define asm_mult 1
+
+#if uECC_SQUARE_FUNC
+uECC_VLI_API void uECC_vli_square(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  wordcount_t num_words) {
+    register uint32_t *r0 __asm__("r0") = result;
+    register const uint32_t *r1 __asm__("r1") = left;
+    register uint32_t r2 __asm__("r2") = num_words;
+    
+#if uECC_SUPPORTS_secp160r1
+    if (num_words == 5) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_SQUARE_ASM_5
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1)
+            : "r" (r2)
+            : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+#if uECC_SUPPORTS_secp192r1
+    if (num_words == 6) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_SQUARE_ASM_6
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1)
+            : "r" (r2)
+            : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+#if uECC_SUPPORTS_secp224r1
+    if (num_words == 7) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_SQUARE_ASM_7
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1)
+            : "r" (r2)
+            : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+#if (uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1)
+    if (num_words == 8) {
+        __asm__ volatile (
+            ".syntax unified \n\t"
+            FAST_SQUARE_ASM_8
+            RESUME_SYNTAX
+            : "+r" (r0), "+r" (r1)
+            : "r" (r2)
+            : "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+        );
+        return;
+    }
+#endif
+}
+#define asm_square 1
+#endif /* uECC_SQUARE_FUNC */
+
+#endif /* (uECC_OPTIMIZATION_LEVEL > 3) */
+
+#endif /* uECC_PLATFORM != uECC_arm_thumb */
+
+#endif /* (uECC_OPTIMIZATION_LEVEL >= 3) */
+
+/* ---- "Small" implementations ---- */
+
+#if !asm_add
+uECC_VLI_API uECC_word_t uECC_vli_add(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+    uint32_t carry = 0;
+    uint32_t left_word;
+    uint32_t right_word;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        "1: \n\t"
+        "ldmia %[lptr]!, {%[left]} \n\t"  /* Load left word. */
+        "ldmia %[rptr]!, {%[right]} \n\t" /* Load right word. */
+        "lsrs %[carry], #1 \n\t"          /* Set up carry flag (carry = 0 after this). */
+        "adcs %[left], %[left], %[right] \n\t"   /* Add with carry. */
+        "adcs %[carry], %[carry], %[carry] \n\t" /* Store carry bit. */
+        "stmia %[dptr]!, {%[left]} \n\t"  /* Store result word. */
+        "subs %[ctr], #1 \n\t"            /* Decrement counter. */
+        "bne 1b \n\t"                     /* Loop until counter == 0. */
+        RESUME_SYNTAX
+        : [dptr] REG_RW (result), [lptr] REG_RW (left), [rptr] REG_RW (right),
+          [ctr] REG_RW (num_words), [carry] REG_RW (carry),
+          [left] REG_WRITE (left_word), [right] REG_WRITE (right_word)
+        :
+        : "cc", "memory"
+    );
+    return carry;
+}
+#define asm_add 1
+#endif
+
+#if !asm_sub
+uECC_VLI_API uECC_word_t uECC_vli_sub(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+    uint32_t carry = 1; /* carry = 1 initially (means don't borrow) */
+    uint32_t left_word;
+    uint32_t right_word;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        "1: \n\t"
+        "ldmia %[lptr]!, {%[left]} \n\t"  /* Load left word. */
+        "ldmia %[rptr]!, {%[right]} \n\t" /* Load right word. */
+        "lsrs %[carry], #1 \n\t"          /* Set up carry flag (carry = 0 after this). */
+        "sbcs %[left], %[left], %[right] \n\t"   /* Subtract with borrow. */
+        "adcs %[carry], %[carry], %[carry] \n\t" /* Store carry bit. */
+        "stmia %[dptr]!, {%[left]} \n\t"  /* Store result word. */
+        "subs %[ctr], #1 \n\t"            /* Decrement counter. */
+        "bne 1b \n\t"                     /* Loop until counter == 0. */
+        RESUME_SYNTAX
+        : [dptr] REG_RW (result), [lptr] REG_RW (left), [rptr] REG_RW (right),
+          [ctr] REG_RW (num_words), [carry] REG_RW (carry),
+          [left] REG_WRITE (left_word), [right] REG_WRITE (right_word)
+        :
+        : "cc", "memory"
+    );
+    return !carry;
+}
+#define asm_sub 1
+#endif
+
+#if !asm_mult
+uECC_VLI_API void uECC_vli_mult(uECC_word_t *result,
+                                const uECC_word_t *left,
+                                const uECC_word_t *right,
+                                wordcount_t num_words) {
+#if (uECC_PLATFORM != uECC_arm_thumb)
+    uint32_t c0 = 0;
+    uint32_t c1 = 0;
+    uint32_t c2 = 0;
+    uint32_t k = 0;
+    uint32_t i;
+    uint32_t t0, t1;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        
+        "1: \n\t" /* outer loop (k < num_words) */
+        "movs %[i], #0 \n\t" /* i = 0 */
+        "b 3f \n\t"
+        
+        "2: \n\t" /* outer loop (k >= num_words) */
+        "movs %[i], %[k] \n\t"         /* i = k */
+        "subs %[i], %[last_word] \n\t" /* i = k - (num_words - 1) (times 4) */
+        
+        "3: \n\t" /* inner loop */
+        "subs %[t0], %[k], %[i] \n\t" /* t0 = k-i */
+        
+        "ldr %[t1], [%[right], %[t0]] \n\t" /* t1 = right[k - i] */
+        "ldr %[t0], [%[left], %[i]] \n\t"   /* t0 = left[i] */
+        
+        "umull %[t0], %[t1], %[t0], %[t1] \n\t" /* (t0, t1) = left[i] * right[k - i] */
+        
+        "adds %[c0], %[c0], %[t0] \n\t" /* add low word to c0 */
+        "adcs %[c1], %[c1], %[t1] \n\t" /* add high word to c1, including carry */
+        "adcs %[c2], %[c2], #0 \n\t"    /* add carry to c2 */
+
+        "adds %[i], #4 \n\t"          /* i += 4 */
+        "cmp %[i], %[last_word] \n\t" /* i > (num_words - 1) (times 4)? */
+        "bgt 4f \n\t"                 /*   if so, exit the loop */
+        "cmp %[i], %[k] \n\t"         /* i <= k? */
+        "ble 3b \n\t"                 /*   if so, continue looping */
+        
+        "4: \n\t" /* end inner loop */
+        
+        "str %[c0], [%[result], %[k]] \n\t" /* result[k] = c0 */
+        "mov %[c0], %[c1] \n\t"       /* c0 = c1 */
+        "mov %[c1], %[c2] \n\t"       /* c1 = c2 */
+        "movs %[c2], #0 \n\t"         /* c2 = 0 */
+        "adds %[k], #4 \n\t"          /* k += 4 */
+        "cmp %[k], %[last_word] \n\t" /* k <= (num_words - 1) (times 4) ? */
+        "ble 1b \n\t"                 /*   if so, loop back, start with i = 0 */
+        "cmp %[k], %[last_word], lsl #1 \n\t" /* k <= (num_words * 2 - 2) (times 4) ? */
+        "ble 2b \n\t"                 /*   if so, loop back, start with i = (k + 1) - num_words */
+        /* end outer loop */
+        
+        "str %[c0], [%[result], %[k]] \n\t" /* result[num_words * 2 - 1] = c0 */
+        RESUME_SYNTAX
+        : [c0] "+r" (c0), [c1] "+r" (c1), [c2] "+r" (c2),
+          [k] "+r" (k), [i] "=&r" (i), [t0] "=&r" (t0), [t1] "=&r" (t1)
+        : [result] "r" (result), [left] "r" (left), [right] "r" (right),
+          [last_word] "r" ((num_words - 1) * 4)
+        : "cc", "memory"
+    );
+    
+#else /* Thumb-1 */
+    uint32_t r4, r5, r6, r7;
+
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        "subs %[r3], #1 \n\t" /* r3 = num_words - 1 */
+        "lsls %[r3], #2 \n\t" /* r3 = (num_words - 1) * 4 */
+        "mov r8, %[r3] \n\t"  /* r8 = (num_words - 1) * 4 */
+        "lsls %[r3], #1 \n\t" /* r3 = (num_words - 1) * 8 */
+        "mov r9, %[r3] \n\t"  /* r9 = (num_words - 1) * 8 */
+        "movs %[r3], #0 \n\t" /* c0 = 0 */
+        "movs %[r4], #0 \n\t" /* c1 = 0 */
+        "movs %[r5], #0 \n\t" /* c2 = 0 */
+        "movs %[r6], #0 \n\t" /* k = 0 */
+        
+        "push {%[r0]} \n\t" /* keep result on the stack */
+        
+        "1: \n\t" /* outer loop (k < num_words) */
+        "movs %[r7], #0 \n\t" /* r7 = i = 0 */
+        "b 3f \n\t"
+        
+        "2: \n\t" /* outer loop (k >= num_words) */
+        "movs %[r7], %[r6] \n\t" /* r7 = k */
+        "mov %[r0], r8 \n\t"     /* r0 = (num_words - 1) * 4 */
+        "subs %[r7], %[r0] \n\t" /* r7 = i = k - (num_words - 1) (times 4) */
+        
+        "3: \n\t" /* inner loop */
+        "mov r10, %[r3] \n\t"
+        "mov r11, %[r4] \n\t"
+        "mov r12, %[r5] \n\t"
+        "mov r14, %[r6] \n\t"
+        "subs %[r0], %[r6], %[r7] \n\t"          /* r0 = k - i */
+        
+        "ldr %[r4], [%[r2], %[r0]] \n\t" /* r4 = right[k - i] */
+        "ldr %[r0], [%[r1], %[r7]] \n\t" /* r0 = left[i] */
+        
+        "lsrs %[r3], %[r0], #16 \n\t" /* r3 = a1 */
+        "uxth %[r0], %[r0] \n\t"      /* r0 = a0 */
+        
+        "lsrs %[r5], %[r4], #16 \n\t" /* r5 = b1 */
+        "uxth %[r4], %[r4] \n\t"      /* r4 = b0 */
+        
+        "movs %[r6], %[r3] \n\t"        /* r6 = a1 */
+        "muls %[r6], %[r5], %[r6] \n\t" /* r6 = a1 * b1 */
+        "muls %[r3], %[r4], %[r3] \n\t" /* r3 = b0 * a1 */
+        "muls %[r5], %[r0], %[r5] \n\t" /* r5 = a0 * b1 */
+        "muls %[r0], %[r4], %[r0] \n\t" /* r0 = a0 * b0 */
+        
+        /* Add middle terms */
+        "lsls %[r4], %[r3], #16 \n\t"
+        "lsrs %[r3], %[r3], #16 \n\t"
+        "adds %[r0], %[r4] \n\t"
+        "adcs %[r6], %[r3] \n\t"
+        
+        "lsls %[r4], %[r5], #16 \n\t"
+        "lsrs %[r5], %[r5], #16 \n\t"
+        "adds %[r0], %[r4] \n\t"
+        "adcs %[r6], %[r5] \n\t"
+        
+        "mov %[r3], r10\n\t"
+        "mov %[r4], r11\n\t"
+        "mov %[r5], r12\n\t"
+        "adds %[r3], %[r0] \n\t"         /* add low word to c0 */
+        "adcs %[r4], %[r6] \n\t"         /* add high word to c1, including carry */
+        "movs %[r0], #0 \n\t"            /* r0 = 0 (does not affect carry bit) */
+        "adcs %[r5], %[r0] \n\t"         /* add carry to c2 */
+        
+        "mov %[r6], r14\n\t" /* r6 = k */
+
+        "adds %[r7], #4 \n\t"   /* i += 4 */
+        "cmp %[r7], r8 \n\t"    /* i > (num_words - 1) (times 4)? */
+        "bgt 4f \n\t"           /*   if so, exit the loop */
+        "cmp %[r7], %[r6] \n\t" /* i <= k? */
+        "ble 3b \n\t"           /*   if so, continue looping */
+        
+        "4: \n\t" /* end inner loop */
+        
+        "ldr %[r0], [sp, #0] \n\t" /* r0 = result */
+        
+        "str %[r3], [%[r0], %[r6]] \n\t" /* result[k] = c0 */
+        "mov %[r3], %[r4] \n\t"          /* c0 = c1 */
+        "mov %[r4], %[r5] \n\t"          /* c1 = c2 */
+        "movs %[r5], #0 \n\t"            /* c2 = 0 */
+        "adds %[r6], #4 \n\t"            /* k += 4 */
+        "cmp %[r6], r8 \n\t"             /* k <= (num_words - 1) (times 4) ? */
+        "ble 1b \n\t"                    /*   if so, loop back, start with i = 0 */
+        "cmp %[r6], r9 \n\t"             /* k <= (num_words * 2 - 2) (times 4) ? */
+        "ble 2b \n\t"                    /*   if so, loop back, with i = (k + 1) - num_words */
+        /* end outer loop */
+        
+        "str %[r3], [%[r0], %[r6]] \n\t" /* result[num_words * 2 - 1] = c0 */
+        "pop {%[r0]} \n\t"               /* pop result off the stack */
+        
+        ".syntax divided \n\t"
+        : [r3] "+l" (num_words), [r4] "=&l" (r4),
+          [r5] "=&l" (r5), [r6] "=&l" (r6), [r7] "=&l" (r7)
+        : [r0] "l" (result), [r1] "l" (left), [r2] "l" (right)
+        : "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+    );
+#endif
+}
+#define asm_mult 1
+#endif
+
+#if uECC_SQUARE_FUNC
+#if !asm_square
+uECC_VLI_API void uECC_vli_square(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  wordcount_t num_words) {
+#if (uECC_PLATFORM != uECC_arm_thumb)
+    uint32_t c0 = 0;
+    uint32_t c1 = 0;
+    uint32_t c2 = 0;
+    uint32_t k = 0;
+    uint32_t i, tt;
+    uint32_t t0, t1;
+    
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        
+        "1: \n\t" /* outer loop (k < num_words) */
+        "movs %[i], #0 \n\t" /* i = 0 */
+        "b 3f \n\t"
+        
+        "2: \n\t" /* outer loop (k >= num_words) */
+        "movs %[i], %[k] \n\t"         /* i = k */
+        "subs %[i], %[last_word] \n\t" /* i = k - (num_words - 1) (times 4) */
+        
+        "3: \n\t" /* inner loop */
+        "subs %[tt], %[k], %[i] \n\t" /* tt = k-i */
+        
+        "ldr %[t1], [%[left], %[tt]] \n\t" /* t1 = left[k - i] */
+        "ldr %[t0], [%[left], %[i]] \n\t"  /* t0 = left[i] */
+        
+        "umull %[t0], %[t1], %[t0], %[t1] \n\t" /* (t0, t1) = left[i] * right[k - i] */
+        
+        "cmp %[i], %[tt] \n\t"      /* (i < k - i) ? */
+        "bge 4f \n\t"               /*   if i >= k - i, skip */
+        "adds %[c0], %[c0], %[t0] \n\t" /* add low word to c0 */
+        "adcs %[c1], %[c1], %[t1] \n\t" /* add high word to c1, including carry */
+        "adcs %[c2], %[c2], #0 \n\t"    /* add carry to c2 */
+        
+        "4: \n\t"
+        "adds %[c0], %[c0], %[t0] \n\t" /* add low word to c0 */
+        "adcs %[c1], %[c1], %[t1] \n\t" /* add high word to c1, including carry */
+        "adcs %[c2], %[c2], #0 \n\t"    /* add carry to c2 */
+        
+        "adds %[i], #4 \n\t"          /* i += 4 */
+        "cmp %[i], %[k] \n\t"         /* i >= k? */
+        "bge 5f \n\t"                 /*   if so, exit the loop */
+        "subs %[tt], %[k], %[i] \n\t" /* tt = k - i */
+        "cmp %[i], %[tt] \n\t"        /* i <= k - i? */
+        "ble 3b \n\t"                 /*   if so, continue looping */
+        
+        "5: \n\t" /* end inner loop */
+        
+        "str %[c0], [%[result], %[k]] \n\t" /* result[k] = c0 */
+        "mov %[c0], %[c1] \n\t"       /* c0 = c1 */
+        "mov %[c1], %[c2] \n\t"       /* c1 = c2 */
+        "movs %[c2], #0 \n\t"         /* c2 = 0 */
+        "adds %[k], #4 \n\t"          /* k += 4 */
+        "cmp %[k], %[last_word] \n\t" /* k <= (num_words - 1) (times 4) ? */
+        "ble 1b \n\t"                 /*   if so, loop back, start with i = 0 */
+        "cmp %[k], %[last_word], lsl #1 \n\t" /* k <= (num_words * 2 - 2) (times 4) ? */
+        "ble 2b \n\t"                 /*   if so, loop back, start with i = (k + 1) - num_words */
+        /* end outer loop */
+        
+        "str %[c0], [%[result], %[k]] \n\t" /* result[num_words * 2 - 1] = c0 */
+        RESUME_SYNTAX
+        : [c0] "+r" (c0), [c1] "+r" (c1), [c2] "+r" (c2),
+          [k] "+r" (k), [i] "=&r" (i), [tt] "=&r" (tt), [t0] "=&r" (t0), [t1] "=&r" (t1)
+        : [result] "r" (result), [left] "r" (left), [last_word] "r" ((num_words - 1) * 4)
+        : "cc", "memory"
+    );
+    
+#else
+    uint32_t r3, r4, r5, r6, r7;
+
+    __asm__ volatile (
+        ".syntax unified \n\t"
+        "subs %[r2], #1 \n\t" /* r2 = num_words - 1 */
+        "lsls %[r2], #2 \n\t" /* r2 = (num_words - 1) * 4 */
+        "mov r8, %[r2] \n\t"  /* r8 = (num_words - 1) * 4 */
+        "lsls %[r2], #1 \n\t" /* r2 = (num_words - 1) * 8 */
+        "mov r9, %[r2] \n\t"  /* r9 = (num_words - 1) * 8 */
+        "movs %[r2], #0 \n\t" /* c0 = 0 */
+        "movs %[r3], #0 \n\t" /* c1 = 0 */
+        "movs %[r4], #0 \n\t" /* c2 = 0 */
+        "movs %[r5], #0 \n\t" /* k = 0 */
+        
+        "push {%[r0]} \n\t" /* keep result on the stack */
+        
+        "1: \n\t" /* outer loop (k < num_words) */
+        "movs %[r6], #0 \n\t" /* r6 = i = 0 */
+        "b 3f \n\t"
+        
+        "2: \n\t" /* outer loop (k >= num_words) */
+        "movs %[r6], %[r5] \n\t" /* r6 = k */
+        "mov %[r0], r8 \n\t"     /* r0 = (num_words - 1) * 4 */
+        "subs %[r6], %[r0] \n\t" /* r6 = i = k - (num_words - 1) (times 4) */
+        
+        "3: \n\t" /* inner loop */
+        "mov r10, %[r2] \n\t"
+        "mov r11, %[r3] \n\t"
+        "mov r12, %[r4] \n\t"
+        "mov r14, %[r5] \n\t"
+        "subs %[r7], %[r5], %[r6] \n\t"  /* r7 = k - i */
+        
+        "ldr %[r3], [%[r1], %[r7]] \n\t" /* r3 = left[k - i] */
+        "ldr %[r0], [%[r1], %[r6]] \n\t" /* r0 = left[i] */
+        
+        "lsrs %[r2], %[r0], #16 \n\t" /* r2 = a1 */
+        "uxth %[r0], %[r0] \n\t"      /* r0 = a0 */
+        
+        "lsrs %[r4], %[r3], #16 \n\t" /* r4 = b1 */
+        "uxth %[r3], %[r3] \n\t"      /* r3 = b0 */
+        
+        "movs %[r5], %[r2] \n\t"        /* r5 = a1 */
+        "muls %[r5], %[r4], %[r5] \n\t" /* r5 = a1 * b1 */
+        "muls %[r2], %[r3], %[r2] \n\t" /* r2 = b0 * a1 */
+        "muls %[r4], %[r0], %[r4] \n\t" /* r4 = a0 * b1 */
+        "muls %[r0], %[r3], %[r0] \n\t" /* r0 = a0 * b0 */
+        
+        /* Add middle terms */
+        "lsls %[r3], %[r2], #16 \n\t"
+        "lsrs %[r2], %[r2], #16 \n\t"
+        "adds %[r0], %[r3] \n\t"
+        "adcs %[r5], %[r2] \n\t"
+        
+        "lsls %[r3], %[r4], #16 \n\t"
+        "lsrs %[r4], %[r4], #16 \n\t"
+        "adds %[r0], %[r3] \n\t"
+        "adcs %[r5], %[r4] \n\t"
+        
+        /* Add to acc, doubling if necessary */
+        "mov %[r2], r10\n\t"
+        "mov %[r3], r11\n\t"
+        "mov %[r4], r12\n\t"
+        
+        "cmp %[r6], %[r7] \n\t"    /* (i < k - i) ? */
+        "bge 4f \n\t"            /*   if i >= k - i, skip */
+        "movs %[r7], #0 \n\t"    /* r7 = 0 */
+        "adds %[r2], %[r0] \n\t" /* add low word to c0 */
+        "adcs %[r3], %[r5] \n\t" /* add high word to c1, including carry */
+        "adcs %[r4], %[r7] \n\t" /* add carry to c2 */
+        "4: \n\t"
+        "movs %[r7], #0 \n\t"    /* r7 = 0 */
+        "adds %[r2], %[r0] \n\t" /* add low word to c0 */
+        "adcs %[r3], %[r5] \n\t" /* add high word to c1, including carry */
+        "adcs %[r4], %[r7] \n\t" /* add carry to c2 */
+        
+        "mov %[r5], r14\n\t" /* r5 = k */
+        
+        "adds %[r6], #4 \n\t"           /* i += 4 */
+        "cmp %[r6], %[r5] \n\t"         /* i >= k? */
+        "bge 5f \n\t"                   /*   if so, exit the loop */
+        "subs %[r7], %[r5], %[r6] \n\t" /* r7 = k - i */
+        "cmp %[r6], %[r7] \n\t"         /* i <= k - i? */
+        "ble 3b \n\t"                   /*   if so, continue looping */
+        
+        "5: \n\t" /* end inner loop */
+        
+        "ldr %[r0], [sp, #0] \n\t" /* r0 = result */
+        
+        "str %[r2], [%[r0], %[r5]] \n\t" /* result[k] = c0 */
+        "mov %[r2], %[r3] \n\t"          /* c0 = c1 */
+        "mov %[r3], %[r4] \n\t"          /* c1 = c2 */
+        "movs %[r4], #0 \n\t"            /* c2 = 0 */
+        "adds %[r5], #4 \n\t"            /* k += 4 */
+        "cmp %[r5], r8 \n\t"             /* k <= (num_words - 1) (times 4) ? */
+        "ble 1b \n\t"                    /*   if so, loop back, start with i = 0 */
+        "cmp %[r5], r9 \n\t"             /* k <= (num_words * 2 - 2) (times 4) ? */
+        "ble 2b \n\t"                    /*   if so, loop back, with i = (k + 1) - num_words */
+        /* end outer loop */
+        
+        "str %[r2], [%[r0], %[r5]] \n\t" /* result[num_words * 2 - 1] = c0 */
+        "pop {%[r0]} \n\t"               /* pop result off the stack */
+
+        ".syntax divided \n\t"
+        : [r2] "+l" (num_words), [r3] "=&l" (r3), [r4] "=&l" (r4),
+          [r5] "=&l" (r5), [r6] "=&l" (r6), [r7] "=&l" (r7)
+        : [r0] "l" (result), [r1] "l" (left)
+        : "r8", "r9", "r10", "r11", "r12", "r14", "cc", "memory"
+    );
+#endif
+}
+#define asm_square 1
+#endif
+#endif /* uECC_SQUARE_FUNC */
+
+#endif /* _UECC_ASM_ARM_H_ */
diff --git a/lib/micro-ecc/asm_arm_mult_square.inc b/lib/micro-ecc/asm_arm_mult_square.inc
new file mode 100644
index 00000000..8907fc18
--- /dev/null
+++ b/lib/micro-ecc/asm_arm_mult_square.inc
@@ -0,0 +1,2311 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_ASM_ARM_MULT_SQUARE_H_
+#define _UECC_ASM_ARM_MULT_SQUARE_H_
+
+#define FAST_MULT_ASM_5                \
+    "push {r3} \n\t"                   \
+    "add r0, 12 \n\t"                  \
+    "add r2, 12 \n\t"                  \
+    "ldmia r1!, {r3,r4} \n\t"          \
+    "ldmia r2!, {r6,r7} \n\t"          \
+                                       \
+    "umull r11, r12, r3, r6 \n\t"      \
+    "stmia r0!, {r11} \n\t"            \
+                                       \
+    "mov r10, #0 \n\t"                 \
+    "umull r11, r9, r3, r7 \n\t"       \
+    "adds r12, r12, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r11, r14, r4, r6 \n\t"      \
+    "adds r12, r12, r11 \n\t"          \
+    "adcs r9, r9, r14 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "stmia r0!, {r12} \n\t"            \
+                                       \
+    "umull r12, r14, r4, r7 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adc r10, r10, r14 \n\t"           \
+    "stmia r0!, {r9, r10} \n\t"        \
+                                       \
+    "sub r0, 28 \n\t"                  \
+    "sub r2, 20 \n\t"                  \
+    "ldmia r2!, {r6,r7,r8} \n\t"       \
+    "ldmia r1!, {r5} \n\t"             \
+                                       \
+    "umull r11, r12, r3, r6 \n\t"      \
+    "stmia r0!, {r11} \n\t"            \
+                                       \
+    "mov r10, #0 \n\t"                 \
+    "umull r11, r9, r3, r7 \n\t"       \
+    "adds r12, r12, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r11, r14, r4, r6 \n\t"      \
+    "adds r12, r12, r11 \n\t"          \
+    "adcs r9, r9, r14 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "stmia r0!, {r12} \n\t"            \
+                                       \
+    "mov r11, #0 \n\t"                 \
+    "umull r12, r14, r3, r8 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r4, r7 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r5, r6 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "ldmia r1!, {r3} \n\t"             \
+    "mov r12, #0 \n\t"                 \
+    "umull r14, r9, r4, r8 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r5, r7 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r3, r6 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "ldr r14, [r0] \n\t"               \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, #0 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "stmia r0!, {r10} \n\t"            \
+                                       \
+    "ldmia r1!, {r4} \n\t"             \
+    "mov r14, #0 \n\t"                 \
+    "umull r9, r10, r5, r8 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "umull r9, r10, r3, r7 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "umull r9, r10, r4, r6 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "ldr r9, [r0] \n\t"                \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, #0 \n\t"           \
+    "adc r14, r14, #0 \n\t"            \
+    "stmia r0!, {r11} \n\t"            \
+                                       \
+    "ldmia r2!, {r6} \n\t"             \
+    "mov r9, #0 \n\t"                  \
+    "umull r10, r11, r5, r6 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r3, r8 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r4, r7 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "ldr r10, [r0] \n\t"               \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, #0 \n\t"           \
+    "adc r9, r9, #0 \n\t"              \
+    "stmia r0!, {r12} \n\t"            \
+                                       \
+    "ldmia r2!, {r7} \n\t"             \
+    "mov r10, #0 \n\t"                 \
+    "umull r11, r12, r5, r7 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r3, r6 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r4, r8 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "ldr r11, [r0] \n\t"               \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, #0 \n\t"             \
+    "adc r10, r10, #0 \n\t"            \
+    "stmia r0!, {r14} \n\t"            \
+                                       \
+    "mov r11, #0 \n\t"                 \
+    "umull r12, r14, r3, r7 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r4, r6 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "umull r14, r9, r4, r7 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adc r11, r11, r9 \n\t"            \
+    "stmia r0!, {r10, r11} \n\t"       \
+    "pop {r3} \n\t"
+
+#define FAST_MULT_ASM_5_TO_6                 \
+    "cmp r3, #5 \n\t"                        \
+    "beq 1f \n\t"                            \
+                                             \
+    /* r4 = left high, r5 = right high */    \
+    "ldr r4, [r1] \n\t"                      \
+    "ldr r5, [r2] \n\t"                      \
+                                             \
+    "sub r0, #20 \n\t"                       \
+    "sub r1, #20 \n\t"                       \
+    "sub r2, #20 \n\t"                       \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r14, #0 \n\t"                       \
+    "umull r9, r10, r4, r8 \n\t"             \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r9, r9, r6 \n\t"                   \
+    "adc r10, r10, #0 \n\t"                  \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "str r9, [r0], #4 \n\t"                  \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r10, r10, r6 \n\t"                 \
+    "adcs r14, r14, #0 \n\t"                 \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r9, #0 \n\t"                        \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "str r10, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r14, r14, r6 \n\t"                 \
+    "adcs r9, r9, #0 \n\t"                   \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r10, #0 \n\t"                       \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r14, r14, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                  \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r14, r14, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                  \
+    "str r14, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r9, r9, r6 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r14, #0 \n\t"                       \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "str r9, [r0], #4 \n\t"                  \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r10, r10, r6 \n\t"                 \
+    "adcs r14, r14, #0 \n\t"                 \
+    /* skip past already-loaded (r4, r5) */  \
+    "ldr r7, [r1], #8 \n\t"                  \
+    "ldr r8, [r2], #8 \n\t"                  \
+    "mov r9, #0 \n\t"                        \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "str r10, [r0], #4 \n\t"                 \
+                                             \
+    "umull r11, r12, r4, r5 \n\t"            \
+    "adds r11, r11, r14 \n\t"                \
+    "adc r12, r12, r9 \n\t"                  \
+    "stmia r0!, {r11, r12} \n\t"
+
+#define FAST_MULT_ASM_6             \
+    "push {r3} \n\t"                \
+    "add r0, 12 \n\t"               \
+    "add r2, 12 \n\t"               \
+    "ldmia r1!, {r3,r4,r5} \n\t"    \
+    "ldmia r2!, {r6,r7,r8} \n\t"    \
+                                    \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r9, r3, r7 \n\t"    \
+    "adds r12, r12, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r11, r14, r4, r6 \n\t"   \
+    "adds r12, r12, r11 \n\t"       \
+    "adcs r9, r9, r14 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r3, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r5, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r4, r8 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r5, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "umull r9, r10, r5, r8 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adc r12, r12, r10 \n\t"        \
+    "stmia r0!, {r11, r12} \n\t"    \
+                                    \
+    "sub r0, 36 \n\t"               \
+    "sub r2, 24 \n\t"               \
+    "ldmia r2!, {r6,r7,r8} \n\t"    \
+                                    \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r9, r3, r7 \n\t"    \
+    "adds r12, r12, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r11, r14, r4, r6 \n\t"   \
+    "adds r12, r12, r11 \n\t"       \
+    "adcs r9, r9, r14 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r3, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r5, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "ldmia r1!, {r3} \n\t"          \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r4, r8 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r5, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r3, r6 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "ldr r14, [r0] \n\t"            \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, #0 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "ldmia r1!, {r4} \n\t"          \
+    "mov r14, #0 \n\t"              \
+    "umull r9, r10, r5, r8 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r3, r7 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r4, r6 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "ldr r9, [r0] \n\t"             \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, #0 \n\t"        \
+    "adc r14, r14, #0 \n\t"         \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "ldmia r1!, {r5} \n\t"          \
+    "mov r9, #0 \n\t"               \
+    "umull r10, r11, r3, r8 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r4, r7 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r5, r6 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "ldr r10, [r0] \n\t"            \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, #0 \n\t"        \
+    "adc r9, r9, #0 \n\t"           \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "ldmia r2!, {r6} \n\t"          \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r4, r8 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r5, r7 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "ldr r11, [r0] \n\t"            \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, #0 \n\t"          \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r14} \n\t"         \
+                                    \
+    "ldmia r2!, {r7} \n\t"          \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r3, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r5, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "ldr r12, [r0] \n\t"            \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, #0 \n\t"        \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "ldmia r2!, {r8} \n\t"          \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r3, r8 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r4, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r5, r6 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "ldr r14, [r0] \n\t"            \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, #0 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "mov r14, #0 \n\t"              \
+    "umull r9, r10, r4, r8 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r5, r7 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "umull r10, r11, r5, r8 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adc r14, r14, r11 \n\t"        \
+    "stmia r0!, {r12, r14} \n\t"    \
+    "pop {r3} \n\t"
+
+#define FAST_MULT_ASM_6_TO_7                    \
+    "cmp r3, #6 \n\t"                           \
+    "beq 1f \n\t"                               \
+                                                \
+    /* r4 = left high, r5 = right high */       \
+    "ldr r4, [r1] \n\t"                         \
+    "ldr r5, [r2] \n\t"                         \
+                                                \
+    "sub r0, #24 \n\t"                          \
+    "sub r1, #24 \n\t"                          \
+    "sub r2, #24 \n\t"                          \
+                                                \
+    "ldr r6, [r0] \n\t"                         \
+    "ldr r7, [r1], #4 \n\t"                     \
+    "ldr r8, [r2], #4 \n\t"                     \
+    "mov r14, #0 \n\t"                          \
+    "umull r9, r10, r4, r8 \n\t"                \
+    "umull r11, r12, r5, r7 \n\t"               \
+    "adds r9, r9, r6 \n\t"                      \
+    "adc r10, r10, #0 \n\t"                     \
+    "adds r9, r9, r11 \n\t"                     \
+    "adcs r10, r10, r12 \n\t"                   \
+    "adc r14, r14, #0 \n\t"                     \
+    "str r9, [r0], #4 \n\t"                     \
+                                                \
+    "ldr r6, [r0] \n\t"                         \
+    "adds r10, r10, r6 \n\t"                    \
+    "adcs r14, r14, #0 \n\t"                    \
+    "ldr r7, [r1], #4 \n\t"                     \
+    "ldr r8, [r2], #4 \n\t"                     \
+    "mov r9, #0 \n\t"                           \
+    "umull r11, r12, r4, r8 \n\t"               \
+    "adds r10, r10, r11 \n\t"                   \
+    "adcs r14, r14, r12 \n\t"                   \
+    "adc r9, r9, #0 \n\t"                       \
+    "umull r11, r12, r5, r7 \n\t"               \
+    "adds r10, r10, r11 \n\t"                   \
+    "adcs r14, r14, r12 \n\t"                   \
+    "adc r9, r9, #0 \n\t"                       \
+    "str r10, [r0], #4 \n\t"                    \
+                                                \
+    "ldr r6, [r0] \n\t"                         \
+    "adds r14, r14, r6 \n\t"                    \
+    "adcs r9, r9, #0 \n\t"                      \
+    "ldr r7, [r1], #4 \n\t"                     \
+    "ldr r8, [r2], #4 \n\t"                     \
+    "mov r10, #0 \n\t"                          \
+    "umull r11, r12, r4, r8 \n\t"               \
+    "adds r14, r14, r11 \n\t"                   \
+    "adcs r9, r9, r12 \n\t"                     \
+    "adc r10, r10, #0 \n\t"                     \
+    "umull r11, r12, r5, r7 \n\t"               \
+    "adds r14, r14, r11 \n\t"                   \
+    "adcs r9, r9, r12 \n\t"                     \
+    "adc r10, r10, #0 \n\t"                     \
+    "str r14, [r0], #4 \n\t"                    \
+                                                \
+    "ldr r6, [r0] \n\t"                         \
+    "adds r9, r9, r6 \n\t"                      \
+    "adcs r10, r10, #0 \n\t"                    \
+    "ldr r7, [r1], #4 \n\t"                     \
+    "ldr r8, [r2], #4 \n\t"                     \
+    "mov r14, #0 \n\t"                          \
+    "umull r11, r12, r4, r8 \n\t"               \
+    "adds r9, r9, r11 \n\t"                     \
+    "adcs r10, r10, r12 \n\t"                   \
+    "adc r14, r14, #0 \n\t"                     \
+    "umull r11, r12, r5, r7 \n\t"               \
+    "adds r9, r9, r11 \n\t"                     \
+    "adcs r10, r10, r12 \n\t"                   \
+    "adc r14, r14, #0 \n\t"                     \
+    "str r9, [r0], #4 \n\t"                     \
+                                                \
+    "ldr r6, [r0] \n\t"                         \
+    "adds r10, r10, r6 \n\t"                    \
+    "adcs r14, r14, #0 \n\t"                    \
+    "ldr r7, [r1], #4 \n\t"                     \
+    "ldr r8, [r2], #4 \n\t"                     \
+    "mov r9, #0 \n\t"                           \
+    "umull r11, r12, r4, r8 \n\t"               \
+    "adds r10, r10, r11 \n\t"                   \
+    "adcs r14, r14, r12 \n\t"                   \
+    "adc r9, r9, #0 \n\t"                       \
+    "umull r11, r12, r5, r7 \n\t"               \
+    "adds r10, r10, r11 \n\t"                   \
+    "adcs r14, r14, r12 \n\t"                   \
+    "adc r9, r9, #0 \n\t"                       \
+    "str r10, [r0], #4 \n\t"                    \
+                                                \
+    "ldr r6, [r0] \n\t"                         \
+    "adds r14, r14, r6 \n\t"                    \
+    "adcs r9, r9, #0 \n\t"                      \
+    /* skip past already-loaded (r4, r5) */     \
+    "ldr r7, [r1], #8 \n\t"                     \
+    "ldr r8, [r2], #8 \n\t"                     \
+    "mov r10, #0 \n\t"                          \
+    "umull r11, r12, r4, r8 \n\t"               \
+    "adds r14, r14, r11 \n\t"                   \
+    "adcs r9, r9, r12 \n\t"                     \
+    "adc r10, r10, #0 \n\t"                     \
+    "umull r11, r12, r5, r7 \n\t"               \
+    "adds r14, r14, r11 \n\t"                   \
+    "adcs r9, r9, r12 \n\t"                     \
+    "adc r10, r10, #0 \n\t"                     \
+    "str r14, [r0], #4 \n\t"                    \
+                                                \
+    "umull r11, r12, r4, r5 \n\t"               \
+    "adds r11, r11, r9 \n\t"                    \
+    "adc r12, r12, r10 \n\t"                    \
+    "stmia r0!, {r11, r12} \n\t"
+
+#define FAST_MULT_ASM_7                \
+    "push {r3} \n\t"                   \
+    "add r0, 24 \n\t"                  \
+    "add r2, 24 \n\t"                  \
+    "ldmia r1!, {r3} \n\t"             \
+    "ldmia r2!, {r6} \n\t"             \
+                                       \
+    "umull r9, r10, r3, r6 \n\t"       \
+    "stmia r0!, {r9, r10} \n\t"        \
+                                       \
+    "sub r0, 20 \n\t"                  \
+    "sub r2, 16 \n\t"                  \
+    "ldmia r2!, {r6, r7, r8} \n\t"     \
+    "ldmia r1!, {r4, r5} \n\t"         \
+                                       \
+    "umull r9, r10, r3, r6 \n\t"       \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "mov r14, #0 \n\t"                 \
+    "umull r9, r12, r3, r7 \n\t"       \
+    "adds r10, r10, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r9, r11, r4, r6 \n\t"       \
+    "adds r10, r10, r9 \n\t"           \
+    "adcs r12, r12, r11 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "stmia r0!, {r10} \n\t"            \
+                                       \
+    "mov r9, #0 \n\t"                  \
+    "umull r10, r11, r3, r8 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r4, r7 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r5, r6 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "stmia r0!, {r12} \n\t"            \
+                                       \
+    "ldmia r1!, {r3} \n\t"             \
+    "mov r10, #0 \n\t"                 \
+    "umull r11, r12, r4, r8 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r5, r7 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r3, r6 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "ldr r11, [r0] \n\t"               \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, #0 \n\t"             \
+    "adc r10, r10, #0 \n\t"            \
+    "stmia r0!, {r14} \n\t"            \
+                                       \
+    "ldmia r2!, {r6} \n\t"             \
+    "mov r11, #0 \n\t"                 \
+    "umull r12, r14, r4, r6 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r5, r8 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r3, r7 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "ldr r12, [r0] \n\t"               \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, #0 \n\t"           \
+    "adc r11, r11, #0 \n\t"            \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "mov r12, #0 \n\t"                 \
+    "umull r14, r9, r5, r6 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r3, r8 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "stmia r0!, {r10} \n\t"            \
+                                       \
+    "umull r9, r10, r3, r6 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adc r12, r12, r10 \n\t"           \
+    "stmia r0!, {r11, r12} \n\t"       \
+                                       \
+    "sub r0, 44 \n\t"                  \
+    "sub r1, 16 \n\t"                  \
+    "sub r2, 28 \n\t"                  \
+    "ldmia r1!, {r3,r4,r5} \n\t"       \
+    "ldmia r2!, {r6,r7,r8} \n\t"       \
+                                       \
+    "umull r9, r10, r3, r6 \n\t"       \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "mov r14, #0 \n\t"                 \
+    "umull r9, r12, r3, r7 \n\t"       \
+    "adds r10, r10, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r9, r11, r4, r6 \n\t"       \
+    "adds r10, r10, r9 \n\t"           \
+    "adcs r12, r12, r11 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "stmia r0!, {r10} \n\t"            \
+                                       \
+    "mov r9, #0 \n\t"                  \
+    "umull r10, r11, r3, r8 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r4, r7 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r5, r6 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "stmia r0!, {r12} \n\t"            \
+                                       \
+    "ldmia r1!, {r3} \n\t"             \
+    "mov r10, #0 \n\t"                 \
+    "umull r11, r12, r4, r8 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r5, r7 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r3, r6 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "ldr r11, [r0] \n\t"               \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, #0 \n\t"             \
+    "adc r10, r10, #0 \n\t"            \
+    "stmia r0!, {r14} \n\t"            \
+                                       \
+    "ldmia r1!, {r4} \n\t"             \
+    "mov r11, #0 \n\t"                 \
+    "umull r12, r14, r5, r8 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r3, r7 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r4, r6 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "ldr r12, [r0] \n\t"               \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, #0 \n\t"           \
+    "adc r11, r11, #0 \n\t"            \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "ldmia r1!, {r5} \n\t"             \
+    "mov r12, #0 \n\t"                 \
+    "umull r14, r9, r3, r8 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r4, r7 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r5, r6 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "ldr r14, [r0] \n\t"               \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, #0 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "stmia r0!, {r10} \n\t"            \
+                                       \
+    "ldmia r1!, {r3} \n\t"             \
+    "mov r14, #0 \n\t"                 \
+    "umull r9, r10, r4, r8 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "umull r9, r10, r5, r7 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "umull r9, r10, r3, r6 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "ldr r9, [r0] \n\t"                \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, #0 \n\t"           \
+    "adc r14, r14, #0 \n\t"            \
+    "stmia r0!, {r11} \n\t"            \
+                                       \
+    "ldmia r2!, {r6} \n\t"             \
+    "mov r9, #0 \n\t"                  \
+    "umull r10, r11, r4, r6 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r5, r8 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "umull r10, r11, r3, r7 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, r11 \n\t"          \
+    "adc r9, r9, #0 \n\t"              \
+    "ldr r10, [r0] \n\t"               \
+    "adds r12, r12, r10 \n\t"          \
+    "adcs r14, r14, #0 \n\t"           \
+    "adc r9, r9, #0 \n\t"              \
+    "stmia r0!, {r12} \n\t"            \
+                                       \
+    "ldmia r2!, {r7} \n\t"             \
+    "mov r10, #0 \n\t"                 \
+    "umull r11, r12, r4, r7 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r5, r6 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "umull r11, r12, r3, r8 \n\t"      \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, r12 \n\t"            \
+    "adc r10, r10, #0 \n\t"            \
+    "ldr r11, [r0] \n\t"               \
+    "adds r14, r14, r11 \n\t"          \
+    "adcs r9, r9, #0 \n\t"             \
+    "adc r10, r10, #0 \n\t"            \
+    "stmia r0!, {r14} \n\t"            \
+                                       \
+    "ldmia r2!, {r8} \n\t"             \
+    "mov r11, #0 \n\t"                 \
+    "umull r12, r14, r4, r8 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r5, r7 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "umull r12, r14, r3, r6 \n\t"      \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, r14 \n\t"          \
+    "adc r11, r11, #0 \n\t"            \
+    "ldr r12, [r0] \n\t"               \
+    "adds r9, r9, r12 \n\t"            \
+    "adcs r10, r10, #0 \n\t"           \
+    "adc r11, r11, #0 \n\t"            \
+    "stmia r0!, {r9} \n\t"             \
+                                       \
+    "ldmia r2!, {r6} \n\t"             \
+    "mov r12, #0 \n\t"                 \
+    "umull r14, r9, r4, r6 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r5, r8 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "umull r14, r9, r3, r7 \n\t"       \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, r9 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "ldr r14, [r0] \n\t"               \
+    "adds r10, r10, r14 \n\t"          \
+    "adcs r11, r11, #0 \n\t"           \
+    "adc r12, r12, #0 \n\t"            \
+    "stmia r0!, {r10} \n\t"            \
+                                       \
+    "mov r14, #0 \n\t"                 \
+    "umull r9, r10, r5, r6 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "umull r9, r10, r3, r8 \n\t"       \
+    "adds r11, r11, r9 \n\t"           \
+    "adcs r12, r12, r10 \n\t"          \
+    "adc r14, r14, #0 \n\t"            \
+    "stmia r0!, {r11} \n\t"            \
+                                       \
+    "umull r10, r11, r3, r6 \n\t"      \
+    "adds r12, r12, r10 \n\t"          \
+    "adc r14, r14, r11 \n\t"           \
+    "stmia r0!, {r12, r14} \n\t"       \
+    "pop {r3} \n\t"
+
+#define FAST_MULT_ASM_7_TO_8                 \
+    "cmp r3, #7 \n\t"                        \
+    "beq 1f \n\t"                            \
+                                             \
+    /* r4 = left high, r5 = right high */    \
+    "ldr r4, [r1] \n\t"                      \
+    "ldr r5, [r2] \n\t"                      \
+                                             \
+    "sub r0, #28 \n\t"                       \
+    "sub r1, #28 \n\t"                       \
+    "sub r2, #28 \n\t"                       \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r14, #0 \n\t"                       \
+    "umull r9, r10, r4, r8 \n\t"             \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r9, r9, r6 \n\t"                   \
+    "adc r10, r10, #0 \n\t"                  \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "str r9, [r0], #4 \n\t"                  \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r10, r10, r6 \n\t"                 \
+    "adcs r14, r14, #0 \n\t"                 \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r9, #0 \n\t"                        \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "str r10, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r14, r14, r6 \n\t"                 \
+    "adcs r9, r9, #0 \n\t"                   \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r10, #0 \n\t"                       \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r14, r14, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                  \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r14, r14, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                  \
+    "str r14, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r9, r9, r6 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r14, #0 \n\t"                       \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "str r9, [r0], #4 \n\t"                  \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r10, r10, r6 \n\t"                 \
+    "adcs r14, r14, #0 \n\t"                 \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r9, #0 \n\t"                        \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r10, r10, r11 \n\t"                \
+    "adcs r14, r14, r12 \n\t"                \
+    "adc r9, r9, #0 \n\t"                    \
+    "str r10, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r14, r14, r6 \n\t"                 \
+    "adcs r9, r9, #0 \n\t"                   \
+    "ldr r7, [r1], #4 \n\t"                  \
+    "ldr r8, [r2], #4 \n\t"                  \
+    "mov r10, #0 \n\t"                       \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r14, r14, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                  \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r14, r14, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                  \
+    "str r14, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r6, [r0] \n\t"                      \
+    "adds r9, r9, r6 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+    /* skip past already-loaded (r4, r5) */  \
+    "ldr r7, [r1], #8 \n\t"                  \
+    "ldr r8, [r2], #8 \n\t"                  \
+    "mov r14, #0 \n\t"                       \
+    "umull r11, r12, r4, r8 \n\t"            \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "umull r11, r12, r5, r7 \n\t"            \
+    "adds r9, r9, r11 \n\t"                  \
+    "adcs r10, r10, r12 \n\t"                \
+    "adc r14, r14, #0 \n\t"                  \
+    "str r9, [r0], #4 \n\t"                  \
+                                             \
+    "umull r11, r12, r4, r5 \n\t"            \
+    "adds r11, r11, r10 \n\t"                \
+    "adc r12, r12, r14 \n\t"                 \
+    "stmia r0!, {r11, r12} \n\t"
+
+#define FAST_MULT_ASM_8             \
+    "push {r3} \n\t"                \
+    "add r0, 24 \n\t"               \
+    "add r2, 24 \n\t"               \
+    "ldmia r1!, {r3,r4} \n\t"       \
+    "ldmia r2!, {r6,r7} \n\t"       \
+                                    \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r9, r3, r7 \n\t"    \
+    "adds r12, r12, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r11, r14, r4, r6 \n\t"   \
+    "adds r12, r12, r11 \n\t"       \
+    "adcs r9, r9, r14 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "umull r12, r14, r4, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adc r10, r10, r14 \n\t"        \
+    "stmia r0!, {r9, r10} \n\t"     \
+                                    \
+    "sub r0, 28 \n\t"               \
+    "sub r2, 20 \n\t"               \
+    "ldmia r2!, {r6,r7,r8} \n\t"    \
+    "ldmia r1!, {r5} \n\t"          \
+                                    \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r9, r3, r7 \n\t"    \
+    "adds r12, r12, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r11, r14, r4, r6 \n\t"   \
+    "adds r12, r12, r11 \n\t"       \
+    "adcs r9, r9, r14 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r3, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r5, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "ldmia r1!, {r3} \n\t"          \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r4, r8 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r5, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r3, r6 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "ldr r14, [r0] \n\t"            \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, #0 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "ldmia r1!, {r4} \n\t"          \
+    "mov r14, #0 \n\t"              \
+    "umull r9, r10, r5, r8 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r3, r7 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r4, r6 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "ldr r9, [r0] \n\t"             \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, #0 \n\t"        \
+    "adc r14, r14, #0 \n\t"         \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "ldmia r2!, {r6} \n\t"          \
+    "mov r9, #0 \n\t"               \
+    "umull r10, r11, r5, r6 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r3, r8 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r4, r7 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "ldr r10, [r0] \n\t"            \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, #0 \n\t"        \
+    "adc r9, r9, #0 \n\t"           \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "ldmia r2!, {r7} \n\t"          \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r12, r5, r7 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r4, r8 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "ldr r11, [r0] \n\t"            \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, #0 \n\t"          \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r14} \n\t"         \
+                                    \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r3, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "umull r14, r9, r4, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adc r11, r11, r9 \n\t"         \
+    "stmia r0!, {r10, r11} \n\t"    \
+                                    \
+    "sub r0, 52 \n\t"               \
+    "sub r1, 20 \n\t"               \
+    "sub r2, 32 \n\t"               \
+    "ldmia r1!, {r3,r4,r5} \n\t"    \
+    "ldmia r2!, {r6,r7,r8} \n\t"    \
+                                    \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r9, r3, r7 \n\t"    \
+    "adds r12, r12, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r11, r14, r4, r6 \n\t"   \
+    "adds r12, r12, r11 \n\t"       \
+    "adcs r9, r9, r14 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r3, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r5, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "ldmia r1!, {r3} \n\t"          \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r4, r8 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r5, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r3, r6 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "ldr r14, [r0] \n\t"            \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, #0 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "ldmia r1!, {r4} \n\t"          \
+    "mov r14, #0 \n\t"              \
+    "umull r9, r10, r5, r8 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r3, r7 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r4, r6 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "ldr r9, [r0] \n\t"             \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, #0 \n\t"        \
+    "adc r14, r14, #0 \n\t"         \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "ldmia r1!, {r5} \n\t"          \
+    "mov r9, #0 \n\t"               \
+    "umull r10, r11, r3, r8 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r4, r7 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r5, r6 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "ldr r10, [r0] \n\t"            \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, #0 \n\t"        \
+    "adc r9, r9, #0 \n\t"           \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "ldmia r1!, {r3} \n\t"          \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r12, r4, r8 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r5, r7 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r3, r6 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "ldr r11, [r0] \n\t"            \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, #0 \n\t"          \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r14} \n\t"         \
+                                    \
+    "ldmia r1!, {r4} \n\t"          \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r5, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r3, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "ldr r12, [r0] \n\t"            \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, #0 \n\t"        \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "ldmia r2!, {r6} \n\t"          \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r5, r6 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r3, r8 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r4, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "ldr r14, [r0] \n\t"            \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, #0 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "ldmia r2!, {r7} \n\t"          \
+    "mov r14, #0 \n\t"              \
+    "umull r9, r10, r5, r7 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r3, r6 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "umull r9, r10, r4, r8 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, r10 \n\t"       \
+    "adc r14, r14, #0 \n\t"         \
+    "ldr r9, [r0] \n\t"             \
+    "adds r11, r11, r9 \n\t"        \
+    "adcs r12, r12, #0 \n\t"        \
+    "adc r14, r14, #0 \n\t"         \
+    "stmia r0!, {r11} \n\t"         \
+                                    \
+    "ldmia r2!, {r8} \n\t"          \
+    "mov r9, #0 \n\t"               \
+    "umull r10, r11, r5, r8 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r3, r7 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "umull r10, r11, r4, r6 \n\t"   \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, r11 \n\t"       \
+    "adc r9, r9, #0 \n\t"           \
+    "ldr r10, [r0] \n\t"            \
+    "adds r12, r12, r10 \n\t"       \
+    "adcs r14, r14, #0 \n\t"        \
+    "adc r9, r9, #0 \n\t"           \
+    "stmia r0!, {r12} \n\t"         \
+                                    \
+    "ldmia r2!, {r6} \n\t"          \
+    "mov r10, #0 \n\t"              \
+    "umull r11, r12, r5, r6 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r3, r8 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "umull r11, r12, r4, r7 \n\t"   \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, r12 \n\t"         \
+    "adc r10, r10, #0 \n\t"         \
+    "ldr r11, [r0] \n\t"            \
+    "adds r14, r14, r11 \n\t"       \
+    "adcs r9, r9, #0 \n\t"          \
+    "adc r10, r10, #0 \n\t"         \
+    "stmia r0!, {r14} \n\t"         \
+                                    \
+    "ldmia r2!, {r7} \n\t"          \
+    "mov r11, #0 \n\t"              \
+    "umull r12, r14, r5, r7 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r3, r6 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "umull r12, r14, r4, r8 \n\t"   \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, r14 \n\t"       \
+    "adc r11, r11, #0 \n\t"         \
+    "ldr r12, [r0] \n\t"            \
+    "adds r9, r9, r12 \n\t"         \
+    "adcs r10, r10, #0 \n\t"        \
+    "adc r11, r11, #0 \n\t"         \
+    "stmia r0!, {r9} \n\t"          \
+                                    \
+    "mov r12, #0 \n\t"              \
+    "umull r14, r9, r3, r7 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "umull r14, r9, r4, r6 \n\t"    \
+    "adds r10, r10, r14 \n\t"       \
+    "adcs r11, r11, r9 \n\t"        \
+    "adc r12, r12, #0 \n\t"         \
+    "stmia r0!, {r10} \n\t"         \
+                                    \
+    "umull r9, r10, r4, r7 \n\t"    \
+    "adds r11, r11, r9 \n\t"        \
+    "adc r12, r12, r10 \n\t"        \
+    "stmia r0!, {r11, r12} \n\t"    \
+    "pop {r3} \n\t"
+
+#define FAST_SQUARE_ASM_5               \
+    "push   {r2} \n\t"                  \
+    "ldmia r1!, {r2,r3,r4,r5,r6} \n\t"  \
+    "push   {r1} \n\t"                  \
+                                        \
+    "umull r11, r12, r2, r2 \n\t"       \
+    "stmia r0!, {r11} \n\t"             \
+                                        \
+    "mov r9, #0 \n\t"                   \
+    "umull r10, r11, r2, r3 \n\t"       \
+    "adds r12, r12, r10 \n\t"           \
+    "adcs r8, r11, #0 \n\t"             \
+    "adc r9, r9, #0 \n\t"               \
+    "adds r12, r12, r10 \n\t"           \
+    "adcs r8, r8, r11 \n\t"             \
+    "adc r9, r9, #0 \n\t"               \
+    "stmia r0!, {r12} \n\t"             \
+                                        \
+    "mov r10, #0 \n\t"                  \
+    "umull r11, r12, r2, r4 \n\t"       \
+    "adds r11, r11, r11 \n\t"           \
+    "adcs r12, r12, r12 \n\t"           \
+    "adc r10, r10, #0 \n\t"             \
+    "adds r8, r8, r11 \n\t"             \
+    "adcs r9, r9, r12 \n\t"             \
+    "adc r10, r10, #0 \n\t"             \
+    "umull r11, r12, r3, r3 \n\t"       \
+    "adds r8, r8, r11 \n\t"             \
+    "adcs r9, r9, r12 \n\t"             \
+    "adc r10, r10, #0 \n\t"             \
+    "stmia r0!, {r8} \n\t"              \
+                                        \
+    "mov r12, #0 \n\t"                  \
+    "umull r8, r11, r2, r5 \n\t"        \
+    "umull r1, r14, r3, r4 \n\t"        \
+    "adds r8, r8, r1 \n\t"              \
+    "adcs r11, r11, r14 \n\t"           \
+    "adc r12, r12, #0 \n\t"             \
+    "adds r8, r8, r8 \n\t"              \
+    "adcs r11, r11, r11 \n\t"           \
+    "adc r12, r12, r12 \n\t"            \
+    "adds r8, r8, r9 \n\t"              \
+    "adcs r11, r11, r10 \n\t"           \
+    "adc r12, r12, #0 \n\t"             \
+    "stmia r0!, {r8} \n\t"              \
+                                        \
+    "mov r10, #0 \n\t"                  \
+    "umull r8, r9, r2, r6 \n\t"         \
+    "umull r1, r14, r3, r5 \n\t"        \
+    "adds r8, r8, r1 \n\t"              \
+    "adcs r9, r9, r14 \n\t"             \
+    "adc r10, r10, #0 \n\t"             \
+    "adds r8, r8, r8 \n\t"              \
+    "adcs r9, r9, r9 \n\t"              \
+    "adc r10, r10, r10 \n\t"            \
+    "umull r1, r14, r4, r4 \n\t"        \
+    "adds r8, r8, r1 \n\t"              \
+    "adcs r9, r9, r14 \n\t"             \
+    "adc r10, r10, #0 \n\t"             \
+    "adds r8, r8, r11 \n\t"             \
+    "adcs r9, r9, r12 \n\t"             \
+    "adc r10, r10, #0 \n\t"             \
+    "stmia r0!, {r8} \n\t"              \
+                                        \
+    "mov r12, #0 \n\t"                  \
+    "umull r8, r11, r3, r6 \n\t"        \
+    "umull r1, r14, r4, r5 \n\t"        \
+    "adds r8, r8, r1 \n\t"              \
+    "adcs r11, r11, r14 \n\t"           \
+    "adc r12, r12, #0 \n\t"             \
+    "adds r8, r8, r8 \n\t"              \
+    "adcs r11, r11, r11 \n\t"           \
+    "adc r12, r12, r12 \n\t"            \
+    "adds r8, r8, r9 \n\t"              \
+    "adcs r11, r11, r10 \n\t"           \
+    "adc r12, r12, #0 \n\t"             \
+    "stmia r0!, {r8} \n\t"              \
+                                        \
+    "mov r8, #0 \n\t"                   \
+    "umull r1, r10, r4, r6 \n\t"        \
+    "adds r1, r1, r1 \n\t"              \
+    "adcs r10, r10, r10 \n\t"           \
+    "adc r8, r8, #0 \n\t"               \
+    "adds r11, r11, r1 \n\t"            \
+    "adcs r12, r12, r10 \n\t"           \
+    "adc r8, r8, #0 \n\t"               \
+    "umull r1, r10, r5, r5 \n\t"        \
+    "adds r11, r11, r1 \n\t"            \
+    "adcs r12, r12, r10 \n\t"           \
+    "adc r8, r8, #0 \n\t"               \
+    "stmia r0!, {r11} \n\t"             \
+                                        \
+    "mov r11, #0 \n\t"                  \
+    "umull r1, r10, r5, r6 \n\t"        \
+    "adds r1, r1, r1 \n\t"              \
+    "adcs r10, r10, r10 \n\t"           \
+    "adc r11, r11, #0 \n\t"             \
+    "adds r12, r12, r1 \n\t"            \
+    "adcs r8, r8, r10 \n\t"             \
+    "adc r11, r11, #0 \n\t"             \
+    "stmia r0!, {r12} \n\t"             \
+                                        \
+    "umull r1, r10, r6, r6 \n\t"        \
+    "adds r8, r8, r1 \n\t"              \
+    "adcs r11, r11, r10 \n\t"           \
+    "stmia r0!, {r8, r11} \n\t"         \
+    "pop {r1, r2} \n\t"
+
+#define FAST_SQUARE_ASM_5_TO_6           \
+    "cmp r2, #5 \n\t"                    \
+    "beq 1f \n\t"                        \
+                                         \
+    "sub r0, #20 \n\t"                   \
+    "sub r1, #20 \n\t"                   \
+                                         \
+    /* Do off-center multiplication */   \
+    "ldmia r1!, {r6,r7,r8,r9,r10,r11} \n\t" \
+    "umull r3, r4, r6, r11 \n\t"         \
+    "umull r6, r5, r7, r11 \n\t"         \
+    "adds r4, r4, r6 \n\t"               \
+    "umull r7, r6, r8, r11 \n\t"         \
+    "adcs r5, r5, r7 \n\t"               \
+    "umull r8, r7, r9, r11 \n\t"         \
+    "adcs r6, r6, r8 \n\t"               \
+    "umull r9, r8, r10, r11 \n\t"        \
+    "adcs r7, r7, r9 \n\t"               \
+    "adcs r8, r8, #0 \n\t"               \
+                                         \
+    /* Multiply by 2 */                  \
+    "mov r9, #0 \n\t"                    \
+    "adds r3, r3, r3 \n\t"               \
+    "adcs r4, r4, r4 \n\t"               \
+    "adcs r5, r5, r5 \n\t"               \
+    "adcs r6, r6, r6 \n\t"               \
+    "adcs r7, r7, r7 \n\t"               \
+    "adcs r8, r8, r8 \n\t"               \
+    "adcs r9, r9, #0 \n\t"               \
+                                         \
+    /* Add into previous */              \
+    "ldr r14, [r0], #4 \n\t"             \
+    "adds r3, r3, r14 \n\t"              \
+    "ldr r14, [r0], #4 \n\t"             \
+    "adcs r4, r4, r14 \n\t"              \
+    "ldr r14, [r0], #4 \n\t"             \
+    "adcs r5, r5, r14 \n\t"              \
+    "ldr r14, [r0], #4 \n\t"             \
+    "adcs r6, r6, r14 \n\t"              \
+    "ldr r14, [r0], #4 \n\t"             \
+    "adcs r7, r7, r14 \n\t"              \
+    "adcs r8, r8, #0 \n\t"               \
+    "adcs r9, r9, #0 \n\t"               \
+    "sub r0, #20 \n\t"                   \
+                                         \
+    /* Perform center multiplication */  \
+    "umlal r8, r9, r11, r11 \n\t"        \
+    "stmia r0!, {r3,r4,r5,r6,r7,r8,r9} \n\t"
+
+#define FAST_SQUARE_ASM_6                  \
+    "push   {r2} \n\t"                     \
+    "ldmia r1!, {r2,r3,r4,r5,r6,r7} \n\t"  \
+    "push   {r1} \n\t"                     \
+                                           \
+    "umull r11, r12, r2, r2 \n\t"          \
+    "stmia r0!, {r11} \n\t"                \
+                                           \
+    "mov r9, #0 \n\t"                      \
+    "umull r10, r11, r2, r3 \n\t"          \
+    "adds r12, r12, r10 \n\t"              \
+    "adcs r8, r11, #0 \n\t"                \
+    "adc r9, r9, #0 \n\t"                  \
+    "adds r12, r12, r10 \n\t"              \
+    "adcs r8, r8, r11 \n\t"                \
+    "adc r9, r9, #0 \n\t"                  \
+    "stmia r0!, {r12} \n\t"                \
+                                           \
+    "mov r10, #0 \n\t"                     \
+    "umull r11, r12, r2, r4 \n\t"          \
+    "adds r11, r11, r11 \n\t"              \
+    "adcs r12, r12, r12 \n\t"              \
+    "adc r10, r10, #0 \n\t"                \
+    "adds r8, r8, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "umull r11, r12, r3, r3 \n\t"          \
+    "adds r8, r8, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "stmia r0!, {r8} \n\t"                 \
+                                           \
+    "mov r12, #0 \n\t"                     \
+    "umull r8, r11, r2, r5 \n\t"           \
+    "umull r1, r14, r3, r4 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r11, r11, r14 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "adds r8, r8, r8 \n\t"                 \
+    "adcs r11, r11, r11 \n\t"              \
+    "adc r12, r12, r12 \n\t"               \
+    "adds r8, r8, r9 \n\t"                 \
+    "adcs r11, r11, r10 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "stmia r0!, {r8} \n\t"                 \
+                                           \
+    "mov r10, #0 \n\t"                     \
+    "umull r8, r9, r2, r6 \n\t"            \
+    "umull r1, r14, r3, r5 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r9, r9, r14 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "adds r8, r8, r8 \n\t"                 \
+    "adcs r9, r9, r9 \n\t"                 \
+    "adc r10, r10, r10 \n\t"               \
+    "umull r1, r14, r4, r4 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r9, r9, r14 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "adds r8, r8, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "stmia r0!, {r8} \n\t"                 \
+                                           \
+    "mov r12, #0 \n\t"                     \
+    "umull r8, r11, r2, r7 \n\t"           \
+    "umull r1, r14, r3, r6 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r11, r11, r14 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "umull r1, r14, r4, r5 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r11, r11, r14 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "adds r8, r8, r8 \n\t"                 \
+    "adcs r11, r11, r11 \n\t"              \
+    "adc r12, r12, r12 \n\t"               \
+    "adds r8, r8, r9 \n\t"                 \
+    "adcs r11, r11, r10 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "stmia r0!, {r8} \n\t"                 \
+                                           \
+    "mov r10, #0 \n\t"                     \
+    "umull r8, r9, r3, r7 \n\t"            \
+    "umull r1, r14, r4, r6 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r9, r9, r14 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "adds r8, r8, r8 \n\t"                 \
+    "adcs r9, r9, r9 \n\t"                 \
+    "adc r10, r10, r10 \n\t"               \
+    "umull r1, r14, r5, r5 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r9, r9, r14 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "adds r8, r8, r11 \n\t"                \
+    "adcs r9, r9, r12 \n\t"                \
+    "adc r10, r10, #0 \n\t"                \
+    "stmia r0!, {r8} \n\t"                 \
+                                           \
+    "mov r12, #0 \n\t"                     \
+    "umull r8, r11, r4, r7 \n\t"           \
+    "umull r1, r14, r5, r6 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r11, r11, r14 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "adds r8, r8, r8 \n\t"                 \
+    "adcs r11, r11, r11 \n\t"              \
+    "adc r12, r12, r12 \n\t"               \
+    "adds r8, r8, r9 \n\t"                 \
+    "adcs r11, r11, r10 \n\t"              \
+    "adc r12, r12, #0 \n\t"                \
+    "stmia r0!, {r8} \n\t"                 \
+                                           \
+    "mov r8, #0 \n\t"                      \
+    "umull r1, r10, r5, r7 \n\t"           \
+    "adds r1, r1, r1 \n\t"                 \
+    "adcs r10, r10, r10 \n\t"              \
+    "adc r8, r8, #0 \n\t"                  \
+    "adds r11, r11, r1 \n\t"               \
+    "adcs r12, r12, r10 \n\t"              \
+    "adc r8, r8, #0 \n\t"                  \
+    "umull r1, r10, r6, r6 \n\t"           \
+    "adds r11, r11, r1 \n\t"               \
+    "adcs r12, r12, r10 \n\t"              \
+    "adc r8, r8, #0 \n\t"                  \
+    "stmia r0!, {r11} \n\t"                \
+                                           \
+    "mov r11, #0 \n\t"                     \
+    "umull r1, r10, r6, r7 \n\t"           \
+    "adds r1, r1, r1 \n\t"                 \
+    "adcs r10, r10, r10 \n\t"              \
+    "adc r11, r11, #0 \n\t"                \
+    "adds r12, r12, r1 \n\t"               \
+    "adcs r8, r8, r10 \n\t"                \
+    "adc r11, r11, #0 \n\t"                \
+    "stmia r0!, {r12} \n\t"                \
+                                           \
+    "umull r1, r10, r7, r7 \n\t"           \
+    "adds r8, r8, r1 \n\t"                 \
+    "adcs r11, r11, r10 \n\t"              \
+    "stmia r0!, {r8, r11} \n\t"            \
+    "pop {r1, r2} \n\t"
+
+#define FAST_SQUARE_ASM_6_TO_7               \
+    "cmp r2, #6 \n\t"                        \
+    "beq 1f \n\t"                            \
+                                             \
+    "sub r0, #24 \n\t"                       \
+    "sub r1, #24 \n\t"                       \
+                                             \
+    /* Do off-center multiplication */       \
+    "ldmia r1!, {r6,r7,r8,r9,r10,r11,r12} \n\t" \
+    "umull r3, r4, r6, r12 \n\t"             \
+    "umull r6, r5, r7, r12 \n\t"             \
+    "adds r4, r4, r6 \n\t"                   \
+    "umull r7, r6, r8, r12 \n\t"             \
+    "adcs r5, r5, r7 \n\t"                   \
+    "umull r8, r7, r9, r12 \n\t"             \
+    "adcs r6, r6, r8 \n\t"                   \
+    "umull r9, r8, r10, r12 \n\t"            \
+    "adcs r7, r7, r9 \n\t"                   \
+    "umull r10, r9, r11, r12 \n\t"           \
+    "adcs r8, r8, r10 \n\t"                  \
+    "adcs r9, r9, #0 \n\t"                   \
+                                             \
+    /* Multiply by 2 */                      \
+    "mov r10, #0 \n\t"                       \
+    "adds r3, r3, r3 \n\t"                   \
+    "adcs r4, r4, r4 \n\t"                   \
+    "adcs r5, r5, r5 \n\t"                   \
+    "adcs r6, r6, r6 \n\t"                   \
+    "adcs r7, r7, r7 \n\t"                   \
+    "adcs r8, r8, r8 \n\t"                   \
+    "adcs r9, r9, r9 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+                                             \
+    /* Add into previous */                  \
+    "ldr r14, [r0], #4 \n\t"                 \
+    "adds r3, r3, r14 \n\t"                  \
+    "ldr r14, [r0], #4 \n\t"                 \
+    "adcs r4, r4, r14 \n\t"                  \
+    "ldr r14, [r0], #4 \n\t"                 \
+    "adcs r5, r5, r14 \n\t"                  \
+    "ldr r14, [r0], #4 \n\t"                 \
+    "adcs r6, r6, r14 \n\t"                  \
+    "ldr r14, [r0], #4 \n\t"                 \
+    "adcs r7, r7, r14 \n\t"                  \
+    "ldr r14, [r0], #4 \n\t"                 \
+    "adcs r8, r8, r14 \n\t"                  \
+    "adcs r9, r9, #0 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+    "sub r0, #24 \n\t"                       \
+                                             \
+    /* Perform center multiplication */      \
+    "umlal r9, r10, r12, r12 \n\t"           \
+    "stmia r0!, {r3,r4,r5,r6,r7,r8,r9,r10} \n\t"
+
+#define FAST_SQUARE_ASM_7                          \
+    "push   {r2} \n\t"                             \
+    "ldmia r1!, {r2, r3, r4, r5, r6, r7, r8} \n\t" \
+    "push   {r1} \n\t"                             \
+    "sub r1, 4 \n\t"                               \
+                                                   \
+    "add r0, 24 \n\t"                              \
+    "umull r9, r10, r2, r8 \n\t"                   \
+    "stmia r0!, {r9, r10} \n\t"                    \
+    "sub r0, 32 \n\t"                              \
+                                                   \
+    "umull r11, r12, r2, r2 \n\t"                  \
+    "stmia r0!, {r11} \n\t"                        \
+                                                   \
+    "mov r9, #0 \n\t"                              \
+    "umull r10, r11, r2, r3 \n\t"                  \
+    "adds r12, r12, r10 \n\t"                      \
+    "adcs r8, r11, #0 \n\t"                        \
+    "adc r9, r9, #0 \n\t"                          \
+    "adds r12, r12, r10 \n\t"                      \
+    "adcs r8, r8, r11 \n\t"                        \
+    "adc r9, r9, #0 \n\t"                          \
+    "stmia r0!, {r12} \n\t"                        \
+                                                   \
+    "mov r10, #0 \n\t"                             \
+    "umull r11, r12, r2, r4 \n\t"                  \
+    "adds r11, r11, r11 \n\t"                      \
+    "adcs r12, r12, r12 \n\t"                      \
+    "adc r10, r10, #0 \n\t"                        \
+    "adds r8, r8, r11 \n\t"                        \
+    "adcs r9, r9, r12 \n\t"                        \
+    "adc r10, r10, #0 \n\t"                        \
+    "umull r11, r12, r3, r3 \n\t"                  \
+    "adds r8, r8, r11 \n\t"                        \
+    "adcs r9, r9, r12 \n\t"                        \
+    "adc r10, r10, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r12, #0 \n\t"                             \
+    "umull r8, r11, r2, r5 \n\t"                   \
+    "mov r14, r11 \n\t"                            \
+    "umlal r8, r11, r3, r4 \n\t"                   \
+    "cmp r14, r11 \n\t"                            \
+    "it hi \n\t"                                   \
+    "adchi r12, r12, #0 \n\t"                      \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r11, r11, r11 \n\t"                      \
+    "adc r12, r12, r12 \n\t"                       \
+    "adds r8, r8, r9 \n\t"                         \
+    "adcs r11, r11, r10 \n\t"                      \
+    "adc r12, r12, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r10, #0 \n\t"                             \
+    "umull r8, r9, r2, r6 \n\t"                    \
+    "mov r14, r9 \n\t"                             \
+    "umlal r8, r9, r3, r5 \n\t"                    \
+    "cmp r14, r9 \n\t"                             \
+    "it hi \n\t"                                   \
+    "adchi r10, r10, #0 \n\t"                      \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r9, r9, r9 \n\t"                         \
+    "adc r10, r10, r10 \n\t"                       \
+    "mov r14, r9 \n\t"                             \
+    "umlal r8, r9, r4, r4 \n\t"                    \
+    "cmp r14, r9 \n\t"                             \
+    "it hi \n\t"                                   \
+    "adchi r10, r10, #0 \n\t"                      \
+    "adds r8, r8, r11 \n\t"                        \
+    "adcs r9, r9, r12 \n\t"                        \
+    "adc r10, r10, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r12, #0 \n\t"                             \
+    "umull r8, r11, r2, r7 \n\t"                   \
+    "mov r14, r11 \n\t"                            \
+    "umlal r8, r11, r3, r6 \n\t"                   \
+    "cmp r14, r11 \n\t"                            \
+    "it hi \n\t"                                   \
+    "adchi r12, r12, #0 \n\t"                      \
+    "mov r14, r11 \n\t"                            \
+    "umlal r8, r11, r4, r5 \n\t"                   \
+    "cmp r14, r11 \n\t"                            \
+    "it hi \n\t"                                   \
+    "adchi r12, r12, #0 \n\t"                      \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r11, r11, r11 \n\t"                      \
+    "adc r12, r12, r12 \n\t"                       \
+    "adds r8, r8, r9 \n\t"                         \
+    "adcs r11, r11, r10 \n\t"                      \
+    "adc r12, r12, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "ldmia r1!, {r2} \n\t"                         \
+    "mov r10, #0 \n\t"                             \
+    "umull r8, r9, r3, r7 \n\t"                    \
+    "mov r14, r9 \n\t"                             \
+    "umlal r8, r9, r4, r6 \n\t"                    \
+    "cmp r14, r9 \n\t"                             \
+    "it hi \n\t"                                   \
+    "adchi r10, r10, #0 \n\t"                      \
+    "ldr r14, [r0] \n\t"                           \
+    "adds r8, r8, r14 \n\t"                        \
+    "adcs r9, r9, #0 \n\t"                         \
+    "adc r10, r10, #0 \n\t"                        \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r9, r9, r9 \n\t"                         \
+    "adc r10, r10, r10 \n\t"                       \
+    "mov r14, r9 \n\t"                             \
+    "umlal r8, r9, r5, r5 \n\t"                    \
+    "cmp r14, r9 \n\t"                             \
+    "it hi \n\t"                                   \
+    "adchi r10, r10, #0 \n\t"                      \
+    "adds r8, r8, r11 \n\t"                        \
+    "adcs r9, r9, r12 \n\t"                        \
+    "adc r10, r10, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r12, #0 \n\t"                             \
+    "umull r8, r11, r3, r2 \n\t"                   \
+    "mov r14, r11 \n\t"                            \
+    "umlal r8, r11, r4, r7 \n\t"                   \
+    "cmp r14, r11 \n\t"                            \
+    "it hi \n\t"                                   \
+    "adchi r12, r12, #0 \n\t"                      \
+    "mov r14, r11 \n\t"                            \
+    "umlal r8, r11, r5, r6 \n\t"                   \
+    "cmp r14, r11 \n\t"                            \
+    "it hi \n\t"                                   \
+    "adchi r12, r12, #0 \n\t"                      \
+    "ldr r14, [r0] \n\t"                           \
+    "adds r8, r8, r14 \n\t"                        \
+    "adcs r11, r11, #0 \n\t"                       \
+    "adc r12, r12, #0 \n\t"                        \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r11, r11, r11 \n\t"                      \
+    "adc r12, r12, r12 \n\t"                       \
+    "adds r8, r8, r9 \n\t"                         \
+    "adcs r11, r11, r10 \n\t"                      \
+    "adc r12, r12, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r10, #0 \n\t"                             \
+    "umull r8, r9, r4, r2 \n\t"                    \
+    "mov r14, r9 \n\t"                             \
+    "umlal r8, r9, r5, r7 \n\t"                    \
+    "cmp r14, r9 \n\t"                             \
+    "it hi \n\t"                                   \
+    "adchi r10, r10, #0 \n\t"                      \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r9, r9, r9 \n\t"                         \
+    "adc r10, r10, r10 \n\t"                       \
+    "mov r14, r9 \n\t"                             \
+    "umlal r8, r9, r6, r6 \n\t"                    \
+    "cmp r14, r9 \n\t"                             \
+    "it hi \n\t"                                   \
+    "adchi r10, r10, #0 \n\t"                      \
+    "adds r8, r8, r11 \n\t"                        \
+    "adcs r9, r9, r12 \n\t"                        \
+    "adc r10, r10, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r12, #0 \n\t"                             \
+    "umull r8, r11, r5, r2 \n\t"                   \
+    "mov r14, r11 \n\t"                            \
+    "umlal r8, r11, r6, r7 \n\t"                   \
+    "cmp r14, r11 \n\t"                            \
+    "it hi \n\t"                                   \
+    "adchi r12, r12, #0 \n\t"                      \
+    "adds r8, r8, r8 \n\t"                         \
+    "adcs r11, r11, r11 \n\t"                      \
+    "adc r12, r12, r12 \n\t"                       \
+    "adds r8, r8, r9 \n\t"                         \
+    "adcs r11, r11, r10 \n\t"                      \
+    "adc r12, r12, #0 \n\t"                        \
+    "stmia r0!, {r8} \n\t"                         \
+                                                   \
+    "mov r8, #0 \n\t"                              \
+    "umull r1, r10, r6, r2 \n\t"                   \
+    "adds r1, r1, r1 \n\t"                         \
+    "adcs r10, r10, r10 \n\t"                      \
+    "adc r8, r8, #0 \n\t"                          \
+    "adds r11, r11, r1 \n\t"                       \
+    "adcs r12, r12, r10 \n\t"                      \
+    "adc r8, r8, #0 \n\t"                          \
+    "umull r1, r10, r7, r7 \n\t"                   \
+    "adds r11, r11, r1 \n\t"                       \
+    "adcs r12, r12, r10 \n\t"                      \
+    "adc r8, r8, #0 \n\t"                          \
+    "stmia r0!, {r11} \n\t"                        \
+                                                   \
+    "mov r11, #0 \n\t"                             \
+    "umull r1, r10, r7, r2 \n\t"                   \
+    "adds r1, r1, r1 \n\t"                         \
+    "adcs r10, r10, r10 \n\t"                      \
+    "adc r11, r11, #0 \n\t"                        \
+    "adds r12, r12, r1 \n\t"                       \
+    "adcs r8, r8, r10 \n\t"                        \
+    "adc r11, r11, #0 \n\t"                        \
+    "stmia r0!, {r12} \n\t"                        \
+                                                   \
+    "umull r1, r10, r2, r2 \n\t"                   \
+    "adds r8, r8, r1 \n\t"                         \
+    "adcs r11, r11, r10 \n\t"                      \
+    "stmia r0!, {r8, r11} \n\t"                    \
+    "pop {r1, r2} \n\t"
+
+#define FAST_SQUARE_ASM_7_TO_8           \
+    "cmp r2, #7 \n\t"                    \
+    "beq 1f \n\t"                        \
+                                         \
+    "sub r0, #28 \n\t"                   \
+    "sub r1, #28 \n\t"                   \
+                                         \
+    /* Do off-center multiplication */   \
+    "ldmia r1!, {r6,r7,r8,r9,r10,r11,r12,r14} \n\t" \
+    "umull r3, r4, r6, r14 \n\t"         \
+    "umull r6, r5, r7, r14 \n\t"         \
+    "adds r4, r4, r6 \n\t"               \
+    "umull r7, r6, r8, r14 \n\t"         \
+    "adcs r5, r5, r7 \n\t"               \
+    "umull r8, r7, r9, r14 \n\t"         \
+    "adcs r6, r6, r8 \n\t"               \
+    "umull r9, r8, r10, r14 \n\t"        \
+    "adcs r7, r7, r9 \n\t"               \
+    "umull r10, r9, r11, r14 \n\t"       \
+    "adcs r8, r8, r10 \n\t"              \
+    "umull r11, r10, r12, r14 \n\t"      \
+    "adcs r9, r9, r11 \n\t"              \
+    "adcs r10, r10, #0 \n\t"             \
+                                         \
+    /* Multiply by 2 */                  \
+    "mov r11, #0 \n\t"                   \
+    "adds r3, r3, r3 \n\t"               \
+    "adcs r4, r4, r4 \n\t"               \
+    "adcs r5, r5, r5 \n\t"               \
+    "adcs r6, r6, r6 \n\t"               \
+    "adcs r7, r7, r7 \n\t"               \
+    "adcs r8, r8, r8 \n\t"               \
+    "adcs r9, r9, r9 \n\t"               \
+    "adcs r10, r10, r10 \n\t"            \
+    "adcs r11, r11, #0 \n\t"             \
+                                         \
+    /* Add into previous */              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adds r3, r3, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r4, r4, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r5, r5, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r6, r6, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r7, r7, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r8, r8, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r9, r9, r12 \n\t"              \
+    "adcs r10, r10, #0 \n\t"             \
+    "adcs r11, r11, #0 \n\t"             \
+    "sub r0, #28 \n\t"                   \
+                                         \
+    /* Perform center multiplication */  \
+    "umlal r10, r11, r14, r14 \n\t"      \
+    "stmia r0!, {r3,r4,r5,r6,r7,r8,r9,r10,r11} \n\t"
+
+#define FAST_SQUARE_ASM_8                   \
+    "push   {r2} \n\t"                      \
+    "ldmia r1!, {r2,r3,r4,r5,r6,r7,r8,r9} \n\t" \
+    "push   {r1} \n\t"                      \
+    "sub r1, 8 \n\t"                        \
+                                            \
+    "add r0, 24 \n\t"                       \
+    "umull r10, r11, r2, r8 \n\t"           \
+    "umull r12, r14, r2, r9 \n\t"           \
+    "umull r8, r9, r3, r9 \n\t"             \
+    "adds r11, r11, r12 \n\t"               \
+    "adcs r12, r14, r8 \n\t"                \
+    "adcs r14, r9, #0 \n\t"                 \
+    "stmia r0!, {r10, r11, r12, r14} \n\t"  \
+    "sub r0, 40 \n\t"                       \
+                                            \
+    "umull r11, r12, r2, r2 \n\t"           \
+    "stmia r0!, {r11} \n\t"                 \
+                                            \
+    "mov r9, #0 \n\t"                       \
+    "umull r10, r11, r2, r3 \n\t"           \
+    "adds r12, r12, r10 \n\t"               \
+    "adcs r8, r11, #0 \n\t"                 \
+    "adc r9, r9, #0 \n\t"                   \
+    "adds r12, r12, r10 \n\t"               \
+    "adcs r8, r8, r11 \n\t"                 \
+    "adc r9, r9, #0 \n\t"                   \
+    "stmia r0!, {r12} \n\t"                 \
+                                            \
+    "mov r10, #0 \n\t"                      \
+    "umull r11, r12, r2, r4 \n\t"           \
+    "adds r11, r11, r11 \n\t"               \
+    "adcs r12, r12, r12 \n\t"               \
+    "adc r10, r10, #0 \n\t"                 \
+    "adds r8, r8, r11 \n\t"                 \
+    "adcs r9, r9, r12 \n\t"                 \
+    "adc r10, r10, #0 \n\t"                 \
+    "umull r11, r12, r3, r3 \n\t"           \
+    "adds r8, r8, r11 \n\t"                 \
+    "adcs r9, r9, r12 \n\t"                 \
+    "adc r10, r10, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r12, #0 \n\t"                      \
+    "umull r8, r11, r2, r5 \n\t"            \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r3, r4 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r11, r11, r11 \n\t"               \
+    "adc r12, r12, r12 \n\t"                \
+    "adds r8, r8, r9 \n\t"                  \
+    "adcs r11, r11, r10 \n\t"               \
+    "adc r12, r12, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r10, #0 \n\t"                      \
+    "umull r8, r9, r2, r6 \n\t"             \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r3, r5 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r9, r9, r9 \n\t"                  \
+    "adc r10, r10, r10 \n\t"                \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r4, r4 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "adds r8, r8, r11 \n\t"                 \
+    "adcs r9, r9, r12 \n\t"                 \
+    "adc r10, r10, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r12, #0 \n\t"                      \
+    "umull r8, r11, r2, r7 \n\t"            \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r3, r6 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r4, r5 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r11, r11, r11 \n\t"               \
+    "adc r12, r12, r12 \n\t"                \
+    "adds r8, r8, r9 \n\t"                  \
+    "adcs r11, r11, r10 \n\t"               \
+    "adc r12, r12, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "ldmia r1!, {r2} \n\t"                  \
+    "mov r10, #0 \n\t"                      \
+    "umull r8, r9, r3, r7 \n\t"             \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r4, r6 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "ldr r14, [r0] \n\t"                    \
+    "adds r8, r8, r14 \n\t"                 \
+    "adcs r9, r9, #0 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                 \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r9, r9, r9 \n\t"                  \
+    "adc r10, r10, r10 \n\t"                \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r5, r5 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "adds r8, r8, r11 \n\t"                 \
+    "adcs r9, r9, r12 \n\t"                 \
+    "adc r10, r10, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r12, #0 \n\t"                      \
+    "umull r8, r11, r3, r2 \n\t"            \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r4, r7 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r5, r6 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "ldr r14, [r0] \n\t"                    \
+    "adds r8, r8, r14 \n\t"                 \
+    "adcs r11, r11, #0 \n\t"                \
+    "adc r12, r12, #0 \n\t"                 \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r11, r11, r11 \n\t"               \
+    "adc r12, r12, r12 \n\t"                \
+    "adds r8, r8, r9 \n\t"                  \
+    "adcs r11, r11, r10 \n\t"               \
+    "adc r12, r12, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "ldmia r1!, {r3} \n\t"                  \
+    "mov r10, #0 \n\t"                      \
+    "umull r8, r9, r4, r2 \n\t"             \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r5, r7 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "ldr r14, [r0] \n\t"                    \
+    "adds r8, r8, r14 \n\t"                 \
+    "adcs r9, r9, #0 \n\t"                  \
+    "adc r10, r10, #0 \n\t"                 \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r9, r9, r9 \n\t"                  \
+    "adc r10, r10, r10 \n\t"                \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r6, r6 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "adds r8, r8, r11 \n\t"                 \
+    "adcs r9, r9, r12 \n\t"                 \
+    "adc r10, r10, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r12, #0 \n\t"                      \
+    "umull r8, r11, r4, r3 \n\t"            \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r5, r2 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r6, r7 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "ldr r14, [r0] \n\t"                    \
+    "adds r8, r8, r14 \n\t"                 \
+    "adcs r11, r11, #0 \n\t"                \
+    "adc r12, r12, #0 \n\t"                 \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r11, r11, r11 \n\t"               \
+    "adc r12, r12, r12 \n\t"                \
+    "adds r8, r8, r9 \n\t"                  \
+    "adcs r11, r11, r10 \n\t"               \
+    "adc r12, r12, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r10, #0 \n\t"                      \
+    "umull r8, r9, r5, r3 \n\t"             \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r6, r2 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r9, r9, r9 \n\t"                  \
+    "adc r10, r10, r10 \n\t"                \
+    "mov r14, r9 \n\t"                      \
+    "umlal r8, r9, r7, r7 \n\t"             \
+    "cmp r14, r9 \n\t"                      \
+    "it hi \n\t"                            \
+    "adchi r10, r10, #0 \n\t"               \
+    "adds r8, r8, r11 \n\t"                 \
+    "adcs r9, r9, r12 \n\t"                 \
+    "adc r10, r10, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r12, #0 \n\t"                      \
+    "umull r8, r11, r6, r3 \n\t"            \
+    "mov r14, r11 \n\t"                     \
+    "umlal r8, r11, r7, r2 \n\t"            \
+    "cmp r14, r11 \n\t"                     \
+    "it hi \n\t"                            \
+    "adchi r12, r12, #0 \n\t"               \
+    "adds r8, r8, r8 \n\t"                  \
+    "adcs r11, r11, r11 \n\t"               \
+    "adc r12, r12, r12 \n\t"                \
+    "adds r8, r8, r9 \n\t"                  \
+    "adcs r11, r11, r10 \n\t"               \
+    "adc r12, r12, #0 \n\t"                 \
+    "stmia r0!, {r8} \n\t"                  \
+                                            \
+    "mov r8, #0 \n\t"                       \
+    "umull r1, r10, r7, r3 \n\t"            \
+    "adds r1, r1, r1 \n\t"                  \
+    "adcs r10, r10, r10 \n\t"               \
+    "adc r8, r8, #0 \n\t"                   \
+    "adds r11, r11, r1 \n\t"                \
+    "adcs r12, r12, r10 \n\t"               \
+    "adc r8, r8, #0 \n\t"                   \
+    "umull r1, r10, r2, r2 \n\t"            \
+    "adds r11, r11, r1 \n\t"                \
+    "adcs r12, r12, r10 \n\t"               \
+    "adc r8, r8, #0 \n\t"                   \
+    "stmia r0!, {r11} \n\t"                 \
+                                            \
+    "mov r11, #0 \n\t"                      \
+    "umull r1, r10, r2, r3 \n\t"            \
+    "adds r1, r1, r1 \n\t"                  \
+    "adcs r10, r10, r10 \n\t"               \
+    "adc r11, r11, #0 \n\t"                 \
+    "adds r12, r12, r1 \n\t"                \
+    "adcs r8, r8, r10 \n\t"                 \
+    "adc r11, r11, #0 \n\t"                 \
+    "stmia r0!, {r12} \n\t"                 \
+                                            \
+    "umull r1, r10, r3, r3 \n\t"            \
+    "adds r8, r8, r1 \n\t"                  \
+    "adcs r11, r11, r10 \n\t"               \
+    "stmia r0!, {r8, r11} \n\t"             \
+    "pop {r1, r2} \n\t"
+
+#endif /* _UECC_ASM_ARM_MULT_SQUARE_H_ */
diff --git a/lib/micro-ecc/asm_arm_mult_square_umaal.inc b/lib/micro-ecc/asm_arm_mult_square_umaal.inc
new file mode 100644
index 00000000..c554d20e
--- /dev/null
+++ b/lib/micro-ecc/asm_arm_mult_square_umaal.inc
@@ -0,0 +1,1202 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_ASM_ARM_MULT_SQUARE_H_
+#define _UECC_ASM_ARM_MULT_SQUARE_H_
+
+#define FAST_MULT_ASM_5                     \
+    "push   {r3} \n\t"                      \
+    "ldmia  r2!, {r3, r4, r5, r6, r7} \n\t" \
+    "push   {r2} \n\t"                      \
+                                            \
+    "ldr    r2, [r1], #4 \n\t"              \
+    "umull  r8, r9, r3, r2 \n\t"            \
+    "str    r8, [r0], #4 \n\t"              \
+    "mov    r10, #0 \n\t"                   \
+    "umaal  r9, r10, r4, r2 \n\t"           \
+    "mov    r11, #0 \n\t"                   \
+    "umaal  r10, r11, r5, r2 \n\t"          \
+    "mov    r12, #0 \n\t"                   \
+    "umaal  r11, r12, r6, r2 \n\t"          \
+    "mov    r14, #0 \n\t"                   \
+    "umaal  r12, r14, r7, r2 \n\t"          \
+                                            \
+    "ldr    r2, [r1], #4 \n\t"              \
+    "mov    r8, #0 \n\t"                    \
+    "umaal  r8, r9, r3, r2 \n\t"            \
+    "str    r8, [r0], #4 \n\t"              \
+    "umaal  r9, r10, r4, r2 \n\t"           \
+    "umaal  r10, r11, r5, r2 \n\t"          \
+    "umaal  r11, r12, r6, r2 \n\t"          \
+    "umaal  r12, r14, r7, r2 \n\t"          \
+                                            \
+    "ldr    r2, [r1], #4 \n\t"              \
+    "mov    r8, #0 \n\t"                    \
+    "umaal  r8, r9, r3, r2 \n\t"            \
+    "str    r8, [r0], #4 \n\t"              \
+    "umaal  r9, r10, r4, r2 \n\t"           \
+    "umaal  r10, r11, r5, r2 \n\t"          \
+    "umaal  r11, r12, r6, r2 \n\t"          \
+    "umaal  r12, r14, r7, r2 \n\t"          \
+                                            \
+    "ldr    r2, [r1], #4 \n\t"              \
+    "mov    r8, #0 \n\t"                    \
+    "umaal  r8, r9, r3, r2 \n\t"            \
+    "str    r8, [r0], #4 \n\t"              \
+    "umaal  r9, r10, r4, r2 \n\t"           \
+    "umaal  r10, r11, r5, r2 \n\t"          \
+    "umaal  r11, r12, r6, r2 \n\t"          \
+    "umaal  r12, r14, r7, r2 \n\t"          \
+                                            \
+    "ldr    r2, [r1], #4 \n\t"              \
+    "mov    r8, #0 \n\t"                    \
+    "umaal  r8, r9, r3, r2 \n\t"            \
+    "str    r8, [r0], #4 \n\t"              \
+    "umaal  r9, r10, r4, r2 \n\t"           \
+    "umaal  r10, r11, r5, r2 \n\t"          \
+    "umaal  r11, r12, r6, r2 \n\t"          \
+    "umaal  r12, r14, r7, r2 \n\t"          \
+                                            \
+    "str    r9, [r0], #4 \n\t"              \
+    "str    r10, [r0], #4 \n\t"             \
+    "str    r11, [r0], #4 \n\t"             \
+    "str    r12, [r0], #4 \n\t"             \
+    "str    r14, [r0], #4 \n\t"             \
+                                            \
+    "pop   {r2, r3} \n\t"
+
+#define FAST_MULT_ASM_5_TO_6                 \
+    "cmp r3, #5 \n\t"                        \
+    "beq 1f \n\t"                            \
+                                             \
+    /* r4 = left high */                     \
+    "ldr r4, [r1] \n\t"                      \
+                                             \
+    "sub r0, #20 \n\t"                       \
+    "sub r1, #20 \n\t"                       \
+    "sub r2, #20 \n\t"                       \
+                                             \
+    /* Do right side */                      \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "mov r5, #0 \n\t"                        \
+    "ldr r6, [r0], #4 \n\t"                  \
+    "umaal  r5, r6, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r7, [r0], #4 \n\t"                  \
+    "umaal  r6, r7, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r8, [r0], #4 \n\t"                  \
+    "umaal  r7, r8, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r9, [r0], #4 \n\t"                  \
+    "umaal  r8, r9, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r10, [r0], #4 \n\t"                 \
+    "umaal  r9, r10, r4, r14 \n\t"           \
+    "sub r0, #20 \n\t"                       \
+                                             \
+    /* r4 = right high */                    \
+    "ldr r4, [r2], #4 \n\t"                  \
+                                             \
+    /* Do left side */                       \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "mov r12, #0 \n\t"                       \
+    "umaal  r12, r5, r4, r14 \n\t"           \
+    "str r12, [r0], #4 \n\t"                 \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r5, r6, r4, r14 \n\t"            \
+    "str r5, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r6, r7, r4, r14 \n\t"            \
+    "str r6, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r7, r8, r4, r14 \n\t"            \
+    "str r7, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"            \
+    "str r8, [r0], #4 \n\t"                  \
+                                             \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r9, r10, r4, r14 \n\t"           \
+    "stmia r0!, {r9, r10} \n\t"
+
+#define FAST_MULT_ASM_6                  \
+    "ldmia  r2!, {r4, r5, r6} \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "umull  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "mov    r10, #0 \n\t"                \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "mov    r11, #0 \n\t"                \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "str    r9, [r0], #4 \n\t"           \
+    "str    r10, [r0], #4 \n\t"          \
+    "str    r11, [r0], #4 \n\t"          \
+                                         \
+    "sub r0, #24 \n\t"                   \
+    "sub r1, #24 \n\t"                   \
+    "ldmia  r2!, {r4, r5, r6} \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "mov    r9, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "mov    r10, #0 \n\t"                \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "mov    r11, #0 \n\t"                \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "str    r9, [r0], #4 \n\t"           \
+    "str    r10, [r0], #4 \n\t"          \
+    "str    r11, [r0], #4 \n\t"
+
+#define FAST_MULT_ASM_6_TO_7                 \
+    "cmp r3, #6 \n\t"                        \
+    "beq 1f \n\t"                            \
+                                             \
+    /* r4 = left high */                     \
+    "ldr r4, [r1] \n\t"                      \
+                                             \
+    "sub r0, #24 \n\t"                       \
+    "sub r1, #24 \n\t"                       \
+    "sub r2, #24 \n\t"                       \
+                                             \
+    /* Do right side */                      \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "mov r5, #0 \n\t"                        \
+    "ldr r6, [r0], #4 \n\t"                  \
+    "umaal  r5, r6, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r7, [r0], #4 \n\t"                  \
+    "umaal  r6, r7, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r8, [r0], #4 \n\t"                  \
+    "umaal  r7, r8, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r9, [r0], #4 \n\t"                  \
+    "umaal  r8, r9, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r10, [r0], #4 \n\t"                 \
+    "umaal  r9, r10, r4, r14 \n\t"           \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r11, [r0], #4 \n\t"                 \
+    "umaal  r10, r11, r4, r14 \n\t"          \
+    "sub r0, #24 \n\t"                       \
+                                             \
+    /* r4 = right high */                    \
+    "ldr r4, [r2], #4 \n\t"                  \
+                                             \
+    /* Do left side */                       \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "mov r12, #0 \n\t"                       \
+    "umaal  r12, r5, r4, r14 \n\t"           \
+    "str r12, [r0], #4 \n\t"                 \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r5, r6, r4, r14 \n\t"            \
+    "str r5, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r6, r7, r4, r14 \n\t"            \
+    "str r6, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r7, r8, r4, r14 \n\t"            \
+    "str r7, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"            \
+    "str r8, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r9, r10, r4, r14 \n\t"           \
+    "str r9, [r0], #4 \n\t"                  \
+                                             \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r10, r11, r4, r14 \n\t"          \
+    "stmia r0!, {r10, r11} \n\t"
+
+#define FAST_MULT_ASM_7                  \
+    "ldmia  r2!, {r4, r5, r6, r7} \n\t"  \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "umull  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "mov    r10, #0 \n\t"                \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "mov    r11, #0 \n\t"                \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "mov    r12, #0 \n\t"                \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "str    r9, [r0], #4 \n\t"           \
+    "str    r10, [r0], #4 \n\t"          \
+    "str    r11, [r0], #4 \n\t"          \
+    "str    r12, [r0], #4 \n\t"          \
+                                         \
+    "sub r0, #28 \n\t"                   \
+    "sub r1, #28 \n\t"                   \
+    "ldmia  r2!, {r4, r5, r6} \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "mov    r9, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "mov    r10, #0 \n\t"                \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "mov    r11, #0 \n\t"                \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+                                         \
+    "str    r9, [r0], #4 \n\t"           \
+    "str    r10, [r0], #4 \n\t"          \
+    "str    r11, [r0], #4 \n\t"
+
+#define FAST_MULT_ASM_7_TO_8                 \
+    "cmp r3, #7 \n\t"                        \
+    "beq 1f \n\t"                            \
+    "push {r3} \n\t"                         \
+                                             \
+    /* r4 = left high */                     \
+    "ldr r4, [r1] \n\t"                      \
+                                             \
+    "sub r0, #28 \n\t"                       \
+    "sub r1, #28 \n\t"                       \
+    "sub r2, #28 \n\t"                       \
+                                             \
+    /* Do right side */                      \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "mov r5, #0 \n\t"                        \
+    "ldr r6, [r0], #4 \n\t"                  \
+    "umaal  r5, r6, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r7, [r0], #4 \n\t"                  \
+    "umaal  r6, r7, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r8, [r0], #4 \n\t"                  \
+    "umaal  r7, r8, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r9, [r0], #4 \n\t"                  \
+    "umaal  r8, r9, r4, r14 \n\t"            \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r10, [r0], #4 \n\t"                 \
+    "umaal  r9, r10, r4, r14 \n\t"           \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r11, [r0], #4 \n\t"                 \
+    "umaal  r10, r11, r4, r14 \n\t"          \
+    "ldr r14, [r2], #4 \n\t"                 \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "umaal  r11, r12, r4, r14 \n\t"          \
+    "sub r0, #28 \n\t"                       \
+                                             \
+    /* r4 = right high */                    \
+    "ldr r4, [r2], #4 \n\t"                  \
+                                             \
+    /* Do left side */                       \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "mov r3, #0 \n\t"                        \
+    "umaal  r3, r5, r4, r14 \n\t"            \
+    "str r3, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r5, r6, r4, r14 \n\t"            \
+    "str r5, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r6, r7, r4, r14 \n\t"            \
+    "str r6, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r7, r8, r4, r14 \n\t"            \
+    "str r7, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"            \
+    "str r8, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r9, r10, r4, r14 \n\t"           \
+    "str r9, [r0], #4 \n\t"                  \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r10, r11, r4, r14 \n\t"          \
+    "str r10, [r0], #4 \n\t"                 \
+                                             \
+    "ldr r14, [r1], #4 \n\t"                 \
+    "umaal  r11, r12, r4, r14 \n\t"          \
+    "stmia r0!, {r11, r12} \n\t"             \
+    "pop {r3} \n\t"
+
+#define FAST_MULT_ASM_8                  \
+    "ldmia  r2!, {r4, r5, r6, r7} \n\t"  \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "umull  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "mov    r10, #0 \n\t"                \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "mov    r11, #0 \n\t"                \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "mov    r12, #0 \n\t"                \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "mov    r8, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "str    r9, [r0], #4 \n\t"           \
+    "str    r10, [r0], #4 \n\t"          \
+    "str    r11, [r0], #4 \n\t"          \
+    "str    r12, [r0], #4 \n\t"          \
+                                         \
+    "sub r0, #32 \n\t"                   \
+    "sub r1, #32 \n\t"                   \
+    "ldmia  r2!, {r4, r5, r6, r7} \n\t"  \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "mov    r9, #0 \n\t"                 \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "mov    r10, #0 \n\t"                \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "mov    r11, #0 \n\t"                \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "mov    r12, #0 \n\t"                \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "ldr    r14, [r1], #4 \n\t"          \
+    "ldr    r8, [r0] \n\t"               \
+    "umaal  r8, r9, r4, r14 \n\t"        \
+    "str    r8, [r0], #4 \n\t"           \
+    "umaal  r9, r10, r5, r14 \n\t"       \
+    "umaal  r10, r11, r6, r14 \n\t"      \
+    "umaal  r11, r12, r7, r14 \n\t"      \
+                                         \
+    "str    r9, [r0], #4 \n\t"           \
+    "str    r10, [r0], #4 \n\t"          \
+    "str    r11, [r0], #4 \n\t"          \
+    "str    r12, [r0], #4 \n\t"
+
+#define FAST_SQUARE_ASM_5               \
+    "ldmia r1!, {r9,r10,r11,r12,r14} \n\t" \
+    "push {r1, r2} \n\t"                \
+                                        \
+    "umull r1, r2, r10, r9 \n\t"        \
+    "mov r3, #0 \n\t"                   \
+    "umaal r2, r3, r11, r9 \n\t"        \
+    "mov r4, #0 \n\t"                   \
+    "umaal r3, r4, r12, r9 \n\t"        \
+    "mov r5, #0 \n\t"                   \
+    "umaal r4, r5, r14, r9 \n\t"        \
+                                        \
+    "mov r6, #0 \n\t"                   \
+    "umaal r6, r3, r11, r10 \n\t"       \
+    "umaal r3, r4, r12, r10 \n\t"       \
+    "adds r1, r1, r1 \n\t"              \
+    "adcs r2, r2, r2 \n\t"              \
+    "adcs r6, r6, r6 \n\t"              \
+    "adcs r3, r3, r3 \n\t"              \
+                                        \
+    "umull r7, r8, r9, r9 \n\t"         \
+    /* Store carry in r9 */             \
+    "mov r9, #0 \n\t"                   \
+    "adc r9, r9, #0 \n\t"               \
+    "adds r8, r8, r1 \n\t"              \
+    "stmia r0!, {r7,r8} \n\t"           \
+                                        \
+    "umull r7, r8, r10, r10 \n\t"       \
+    "adcs r7, r7, r2 \n\t"              \
+    "adcs r8, r8, r6 \n\t"              \
+    "stmia r0!, {r7,r8} \n\t"           \
+                                        \
+    "umaal r4, r5, r14, r10 \n\t"       \
+    /* Store carry in r10 */            \
+    "mov r10, #0 \n\t"                  \
+    "adc r10, r10, #0 \n\t"             \
+                                        \
+    "mov r1, #0 \n\t"                   \
+    "umaal r1, r4, r12, r11 \n\t"       \
+    "umaal r4, r5, r14, r11 \n\t"       \
+                                        \
+    "mov r2, #0 \n\t"                   \
+    "umaal r2, r5, r14, r12 \n\t"       \
+    /* Load carry from r9 */            \
+    "lsrs r9, #1 \n\t"                  \
+    "adcs r1, r1, r1 \n\t"              \
+    "adcs r4, r4, r4 \n\t"              \
+    "adcs r2, r2, r2 \n\t"              \
+    "adcs r5, r5, r5 \n\t"              \
+    /* r9 is 0 now */                   \
+    "adc r9, r9, #0 \n\t"               \
+                                        \
+    /* Use carry from r10 */            \
+    "umaal r3, r10, r11, r11 \n\t"      \
+    "adds r10, r10, r1 \n\t"            \
+    "stmia r0!, {r3,r10} \n\t"          \
+                                        \
+    "umull r6, r10, r12, r12 \n\t"      \
+    "adcs r6, r6, r4 \n\t"              \
+    "adcs r10, r10, r2 \n\t"            \
+    "stmia r0!, {r6,r10} \n\t"          \
+                                        \
+    "umull r6, r10, r14, r14 \n\t"      \
+    "adcs r6, r6, r5 \n\t"              \
+    "adcs r10, r10, r9 \n\t"            \
+    "stmia r0!, {r6,r10} \n\t"          \
+    "pop {r1, r2} \n\t"
+
+#define FAST_SQUARE_ASM_5_TO_6           \
+    "cmp r2, #5 \n\t"                    \
+    "beq 1f \n\t"                        \
+                                         \
+    "sub r0, #20 \n\t"                   \
+    "sub r1, #20 \n\t"                   \
+                                         \
+    /* Do off-center multiplication */   \
+    "ldmia r1!, {r5,r6,r7,r8,r9,r14} \n\t" \
+    "umull r3, r4, r5, r14 \n\t"         \
+    "mov r5, #0 \n\t"                    \
+    "umaal r4, r5, r6, r14 \n\t"         \
+    "mov r6, #0 \n\t"                    \
+    "umaal r5, r6, r7, r14 \n\t"         \
+    "mov r7, #0 \n\t"                    \
+    "umaal r6, r7, r8, r14 \n\t"         \
+    "mov r8, #0 \n\t"                    \
+    "umaal r7, r8, r9, r14 \n\t"         \
+                                         \
+    /* Multiply by 2 */                  \
+    "mov r9, #0 \n\t"                    \
+    "adds r3, r3, r3 \n\t"               \
+    "adcs r4, r4, r4 \n\t"               \
+    "adcs r5, r5, r5 \n\t"               \
+    "adcs r6, r6, r6 \n\t"               \
+    "adcs r7, r7, r7 \n\t"               \
+    "adcs r8, r8, r8 \n\t"               \
+    "adcs r9, r9, #0 \n\t"               \
+                                         \
+    /* Add into previous */              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adds r3, r3, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r4, r4, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r5, r5, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r6, r6, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r7, r7, r12 \n\t"              \
+    "adcs r8, r8, #0 \n\t"               \
+    "adcs r9, r9, #0 \n\t"               \
+    "sub r0, #20 \n\t"                   \
+                                         \
+    /* Perform center multiplication */  \
+    "umlal r8, r9, r14, r14 \n\t"        \
+    "stmia r0!, {r3,r4,r5,r6,r7,r8,r9} \n\t"
+
+#define FAST_SQUARE_ASM_6               \
+    "ldmia r1!, {r8,r9,r10,r11,r12,r14} \n\t" \
+    "push {r1, r2} \n\t"                \
+                                        \
+    "umull r1, r2, r9, r8 \n\t"         \
+    "mov r3, #0 \n\t"                   \
+    "umaal r2, r3, r10, r8 \n\t"        \
+    "mov r4, #0 \n\t"                   \
+    "umaal r3, r4, r11, r8 \n\t"        \
+    "mov r5, #0 \n\t"                   \
+    "umaal r4, r5, r12, r8 \n\t"        \
+    "mov r6, #0 \n\t"                   \
+    "umaal r5, r6, r14, r8 \n\t"        \
+                                        \
+    "mov r7, #0 \n\t"                   \
+    "umaal r7, r3, r10, r9 \n\t"        \
+    "umaal r3, r4, r11, r9 \n\t"        \
+    "umaal r4, r5, r12, r9 \n\t"        \
+    "push {r4, r5} \n\t"                \
+    "adds r1, r1, r1 \n\t"              \
+    "adcs r2, r2, r2 \n\t"              \
+    "adcs r7, r7, r7 \n\t"              \
+    "adcs r3, r3, r3 \n\t"              \
+                                        \
+    "umull r4, r5, r8, r8 \n\t"         \
+    /* Store carry in r8 */             \
+    "mov r8, #0 \n\t"                   \
+    "adc r8, r8, #0 \n\t"               \
+    "adds r5, r5, r1 \n\t"              \
+    "stmia r0!, {r4,r5} \n\t"           \
+                                        \
+    "umull r4, r5, r9, r9 \n\t"         \
+    "adcs r4, r4, r2 \n\t"              \
+    "adcs r5, r5, r7 \n\t"              \
+    "stmia r0!, {r4,r5} \n\t"           \
+                                        \
+    "pop {r4, r5} \n\t"                 \
+    "umaal r5, r6, r14, r9 \n\t"        \
+    /* Store carry in r9 */             \
+    "mov r9, #0 \n\t"                   \
+    "adc r9, r9, #0 \n\t"               \
+                                        \
+    "mov r1, #0 \n\t"                   \
+    "umaal r1, r4, r11, r10 \n\t"       \
+    "umaal r4, r5, r12, r10 \n\t"       \
+    "umaal r5, r6, r14, r10 \n\t"       \
+                                        \
+    "mov r2, #0 \n\t"                   \
+    "umaal r2, r5, r12, r11 \n\t"       \
+    "umaal r5, r6, r14, r11 \n\t"       \
+                                        \
+    "mov r7, #0 \n\t"                   \
+    "umaal r7, r6, r14, r12 \n\t"       \
+                                        \
+    /* Load carry from r8 */            \
+    "lsrs r8, #1 \n\t"                  \
+    "adcs r1, r1, r1 \n\t"              \
+    "adcs r4, r4, r4 \n\t"              \
+    "adcs r2, r2, r2 \n\t"              \
+    "adcs r5, r5, r5 \n\t"              \
+    "adcs r7, r7, r7 \n\t"              \
+    "adcs r6, r6, r6 \n\t"              \
+    "adc r8, r8, #0 \n\t"               \
+                                        \
+    /* Use carry from r9 */             \
+    "umaal r3, r9, r10, r10 \n\t"       \
+    "adds r9, r9, r1 \n\t"              \
+    "stmia r0!, {r3,r9} \n\t"           \
+                                        \
+    "umull r9, r10, r11, r11 \n\t"      \
+    "adcs r9, r9, r4 \n\t"              \
+    "adcs r10, r10, r2 \n\t"            \
+    "stmia r0!, {r9,r10} \n\t"          \
+                                        \
+    "umull r9, r10, r12, r12 \n\t"      \
+    "adcs r9, r9, r5 \n\t"              \
+    "adcs r10, r10, r7 \n\t"            \
+    "stmia r0!, {r9,r10} \n\t"          \
+                                        \
+    "umull r9, r10, r14, r14 \n\t"      \
+    "adcs r9, r9, r6 \n\t"              \
+    "adcs r10, r10, r8 \n\t"            \
+    "stmia r0!, {r9,r10} \n\t"          \
+    "pop {r1, r2} \n\t"
+
+#define FAST_SQUARE_ASM_6_TO_7               \
+    "cmp r2, #6 \n\t"                        \
+    "beq 1f \n\t"                            \
+                                             \
+    "sub r0, #24 \n\t"                       \
+    "sub r1, #24 \n\t"                       \
+                                             \
+    /* Do off-center multiplication */       \
+    "ldmia r1!, {r5,r6,r7,r8,r9,r10,r14} \n\t" \
+    "umull r3, r4, r5, r14 \n\t"             \
+    "mov r5, #0 \n\t"                        \
+    "umaal r4, r5, r6, r14 \n\t"             \
+    "mov r6, #0 \n\t"                        \
+    "umaal r5, r6, r7, r14 \n\t"             \
+    "mov r7, #0 \n\t"                        \
+    "umaal r6, r7, r8, r14 \n\t"             \
+    "mov r8, #0 \n\t"                        \
+    "umaal r7, r8, r9, r14 \n\t"             \
+    "mov r9, #0 \n\t"                        \
+    "umaal r8, r9, r10, r14 \n\t"            \
+                                             \
+    /* Multiply by 2 */                      \
+    "mov r10, #0 \n\t"                       \
+    "adds r3, r3, r3 \n\t"                   \
+    "adcs r4, r4, r4 \n\t"                   \
+    "adcs r5, r5, r5 \n\t"                   \
+    "adcs r6, r6, r6 \n\t"                   \
+    "adcs r7, r7, r7 \n\t"                   \
+    "adcs r8, r8, r8 \n\t"                   \
+    "adcs r9, r9, r9 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+                                             \
+    /* Add into previous */                  \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "adds r3, r3, r12 \n\t"                  \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "adcs r4, r4, r12 \n\t"                  \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "adcs r5, r5, r12 \n\t"                  \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "adcs r6, r6, r12 \n\t"                  \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "adcs r7, r7, r12 \n\t"                  \
+    "ldr r12, [r0], #4 \n\t"                 \
+    "adcs r8, r8, r12 \n\t"                  \
+    "adcs r9, r9, #0 \n\t"                   \
+    "adcs r10, r10, #0 \n\t"                 \
+    "sub r0, #24 \n\t"                       \
+                                             \
+    /* Perform center multiplication */      \
+    "umlal r9, r10, r14, r14 \n\t"           \
+    "stmia r0!, {r3,r4,r5,r6,r7,r8,r9,r10} \n\t"
+
+#define FAST_SQUARE_ASM_7               \
+    "ldmia r1!, {r9,r10,r11,r12} \n\t"  \
+    "push {r2} \n\t"                    \
+                                        \
+    "umull r14, r2, r10, r9 \n\t"       \
+    "mov r3, #0 \n\t"                   \
+    "umaal r2, r3, r11, r9 \n\t"        \
+    "mov r4, #0 \n\t"                   \
+    "umaal r3, r4, r12, r9 \n\t"        \
+                                        \
+    "mov r5, #0 \n\t"                   \
+    "umaal r5, r3, r11, r10 \n\t"       \
+    "adds r14, r14, r14 \n\t"           \
+    "adcs r2, r2, r2 \n\t"              \
+    "adcs r5, r5, r5 \n\t"              \
+    /* Store carry in r7 */             \
+    "mov r7, #0 \n\t"                   \
+    "adc r7, r7, #0 \n\t"               \
+                                        \
+    "umull r6, r8, r9, r9 \n\t"         \
+    "adds r8, r8, r14 \n\t"             \
+    "stmia r0!, {r6,r8} \n\t"           \
+                                        \
+    "umull r6, r8, r10, r10 \n\t"       \
+    "adcs r6, r6, r2 \n\t"              \
+    "adcs r8, r8, r5 \n\t"              \
+    "stmia r0!, {r6,r8} \n\t"           \
+    /* Store carry in r8 */             \
+    "mov r8, #0 \n\t"                   \
+    "adc r8, r8, #0 \n\t"               \
+                                        \
+    "ldmia r1!, {r2, r6, r14} \n\t"     \
+    "push {r1} \n\t"                    \
+    "umaal r3, r4, r2, r9 \n\t"         \
+    "mov r5, #0 \n\t"                   \
+    "umaal r4, r5, r6, r9 \n\t"         \
+    "mov r1, #0 \n\t"                   \
+    "umaal r5, r1, r14, r9 \n\t"        \
+                                        \
+    "mov r9, #0 \n\t"                   \
+    "umaal r3, r9, r12, r10 \n\t"       \
+    "umaal r9, r4, r2, r10 \n\t"        \
+    "umaal r4, r5, r6, r10 \n\t"        \
+    "umaal r5, r1, r14, r10 \n\t"       \
+                                        \
+    "mov r10, #0 \n\t"                  \
+    "umaal r10, r9, r12, r11 \n\t"      \
+    "umaal r9, r4, r2, r11 \n\t"        \
+    "umaal r4, r5, r6, r11 \n\t"        \
+    "umaal r5, r1, r14, r11 \n\t"       \
+                                        \
+    /* Load carry from r7 */            \
+    "lsrs r7, #1 \n\t"                  \
+    "adcs r3, r3, r3 \n\t"              \
+    "adcs r10, r10, r10 \n\t"           \
+    "adcs r9, r9, r9 \n\t"              \
+    /* Store carry back in r7 */        \
+    "adc r7, r7, #0 \n\t"               \
+                                        \
+    /* Use carry from r8 */             \
+    "umaal r3, r8, r11, r11 \n\t"       \
+    "adds r8, r8, r10 \n\t"             \
+    "stmia r0!, {r3,r8} \n\t"           \
+    /* Store carry back in r8 */        \
+    "mov r8, #0 \n\t"                   \
+    "adc r8, r8, #0 \n\t"               \
+                                        \
+    "mov r3, #0 \n\t"                   \
+    "umaal r3, r4, r2, r12 \n\t"        \
+    "umaal r4, r5, r6, r12 \n\t"        \
+    "umaal r5, r1, r14, r12 \n\t"       \
+                                        \
+    "mov r10, #0 \n\t"                  \
+    "umaal r10, r5, r6, r2 \n\t"        \
+    "umaal r5, r1, r14, r2 \n\t"        \
+                                        \
+    "mov r11, #0 \n\t"                  \
+    "umaal r11, r1, r14, r6 \n\t"       \
+                                        \
+    /* Load carry from r7 */            \
+    "lsrs r7, #1 \n\t"                  \
+    "adcs r3, r3, r3 \n\t"              \
+    "adcs r4, r4, r4 \n\t"              \
+    "adcs r10, r10, r10 \n\t"           \
+    "adcs r5, r5, r5 \n\t"              \
+    "adcs r11, r11, r11 \n\t"           \
+    "adcs r1, r1, r1 \n\t"              \
+    "adc r7, r7, #0 \n\t"               \
+                                        \
+    /* Use carry from r8 */             \
+    "umaal r8, r9, r12, r12 \n\t"       \
+    "adds r9, r9, r3 \n\t"              \
+    "stmia r0!, {r8,r9} \n\t"           \
+                                        \
+    "umull r8, r9, r2, r2 \n\t"         \
+    "adcs r8, r8, r4 \n\t"              \
+    "adcs r9, r9, r10 \n\t"             \
+    "stmia r0!, {r8,r9} \n\t"           \
+                                        \
+    "umull r8, r9, r6, r6 \n\t"         \
+    "adcs r8, r8, r5 \n\t"              \
+    "adcs r9, r9, r11 \n\t"             \
+    "stmia r0!, {r8,r9} \n\t"           \
+                                        \
+    "umull r8, r9, r14, r14 \n\t"       \
+    "adcs r8, r8, r1 \n\t"              \
+    "adcs r9, r9, r7 \n\t"              \
+    "stmia r0!, {r8,r9} \n\t"           \
+    "pop {r1, r2} \n\t"
+
+#define FAST_SQUARE_ASM_7_TO_8           \
+    "cmp r2, #7 \n\t"                    \
+    "beq 1f \n\t"                        \
+                                         \
+    "sub r0, #28 \n\t"                   \
+    "sub r1, #28 \n\t"                   \
+                                         \
+    /* Do off-center multiplication */   \
+    "ldmia r1!, {r5,r6,r7,r8,r9,r10,r11,r14} \n\t" \
+    "umull r3, r4, r5, r14 \n\t"         \
+    "mov r5, #0 \n\t"                    \
+    "umaal r4, r5, r6, r14 \n\t"         \
+    "mov r6, #0 \n\t"                    \
+    "umaal r5, r6, r7, r14 \n\t"         \
+    "mov r7, #0 \n\t"                    \
+    "umaal r6, r7, r8, r14 \n\t"         \
+    "mov r8, #0 \n\t"                    \
+    "umaal r7, r8, r9, r14 \n\t"         \
+    "mov r9, #0 \n\t"                    \
+    "umaal r8, r9, r10, r14 \n\t"        \
+    "mov r10, #0 \n\t"                   \
+    "umaal r9, r10, r11, r14 \n\t"       \
+                                         \
+    /* Multiply by 2 */                  \
+    "mov r11, #0 \n\t"                   \
+    "adds r3, r3, r3 \n\t"               \
+    "adcs r4, r4, r4 \n\t"               \
+    "adcs r5, r5, r5 \n\t"               \
+    "adcs r6, r6, r6 \n\t"               \
+    "adcs r7, r7, r7 \n\t"               \
+    "adcs r8, r8, r8 \n\t"               \
+    "adcs r9, r9, r9 \n\t"               \
+    "adcs r10, r10, r10 \n\t"            \
+    "adcs r11, r11, #0 \n\t"             \
+                                         \
+    /* Add into previous */              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adds r3, r3, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r4, r4, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r5, r5, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r6, r6, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r7, r7, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r8, r8, r12 \n\t"              \
+    "ldr r12, [r0], #4 \n\t"             \
+    "adcs r9, r9, r12 \n\t"              \
+    "adcs r10, r10, #0 \n\t"             \
+    "adcs r11, r11, #0 \n\t"             \
+    "sub r0, #28 \n\t"                   \
+                                         \
+    /* Perform center multiplication */  \
+    "umlal r10, r11, r14, r14 \n\t"      \
+    "stmia r0!, {r3,r4,r5,r6,r7,r8,r9,r10,r11} \n\t"
+
+#define FAST_SQUARE_ASM_8               \
+    "ldmia r1!, {r10,r11,r12,r14} \n\t" \
+    "push {r2} \n\t"                    \
+                                        \
+    "umull r2, r3, r11, r10 \n\t"       \
+    "mov r4, #0 \n\t"                   \
+    "umaal r3, r4, r12, r10 \n\t"       \
+    "mov r5, #0 \n\t"                   \
+    "umaal r4, r5, r14, r10 \n\t"       \
+                                        \
+    "mov r6, #0 \n\t"                   \
+    "umaal r6, r4, r12, r11 \n\t"       \
+    "adds r2, r2, r2 \n\t"              \
+    "adcs r3, r3, r3 \n\t"              \
+    "adcs r6, r6, r6 \n\t"              \
+    /* Store carry in r7 */             \
+    "mov r7, #0 \n\t"                   \
+    "adc r7, r7, #0 \n\t"               \
+                                        \
+    "umull r8, r9, r10, r10 \n\t"       \
+    "adds r9, r9, r2 \n\t"              \
+    "stmia r0!, {r8,r9} \n\t"           \
+                                        \
+    "umull r8, r9, r11, r11 \n\t"       \
+    "adcs r8, r8, r3 \n\t"              \
+    "adcs r9, r9, r6 \n\t"              \
+    "stmia r0!, {r8,r9} \n\t"           \
+    /* Store carry in r8 */             \
+    "mov r8, #0 \n\t"                   \
+    "adc r8, r8, #0 \n\t"               \
+                                        \
+    "ldmia r1!, {r2, r3} \n\t"          \
+    "push {r1} \n\t"                    \
+    "umaal r4, r5, r2, r10 \n\t"        \
+    "mov r6, #0 \n\t"                   \
+    "umaal r5, r6, r3, r10 \n\t"        \
+                                        \
+    "mov r9, #0 \n\t"                   \
+    "umaal r9, r4, r14, r11 \n\t"       \
+    "umaal r4, r5, r2, r11 \n\t"        \
+                                        \
+    "mov r1, #0 \n\t"                   \
+    "umaal r1, r4, r14, r12 \n\t"       \
+                                        \
+    /* Load carry from r7 */            \
+    "lsrs r7, #1 \n\t"                  \
+    "adcs r9, r9, r9 \n\t"              \
+    "adcs r1, r1, r1 \n\t"              \
+    /* Store carry back in r7 */        \
+    "adc r7, r7, #0 \n\t"               \
+                                        \
+    /* Use carry from r8 */             \
+    "umaal r8, r9, r12, r12 \n\t"       \
+    "adds r9, r9, r1  \n\t"             \
+    "stmia r0!, {r8,r9} \n\t"           \
+    /* Store carry back in r8 */        \
+    "mov r8, #0 \n\t"                   \
+    "adc r8, r8, #0 \n\t"               \
+                                        \
+    "pop {r1} \n\t"                     \
+    /* TODO could fix up r1 value on stack here */      \
+    /* and leave the value on the stack (rather */      \
+    /* than popping) if supporting curves > 256 bits */ \
+    "ldr r9, [r1], #4 \n\t"             \
+    "ldr r1, [r1] \n\t"                 \
+                                        \
+    "push {r7} \n\t"                    \
+    "umaal r5, r6, r9, r10 \n\t"        \
+    "mov r7, #0 \n\t"                   \
+    "umaal r6, r7, r1, r10 \n\t"        \
+    /* Carry now stored in r10 */       \
+    "pop {r10} \n\t"                    \
+                                        \
+    "umaal r4, r5, r3, r11 \n\t"        \
+    "umaal r5, r6, r9, r11 \n\t"        \
+    "umaal r6, r7, r1, r11 \n\t"        \
+                                        \
+    "mov r11, #0 \n\t"                  \
+    "umaal r11, r4, r2, r12 \n\t"       \
+    "umaal r4, r5, r3, r12 \n\t"        \
+    "umaal r5, r6, r9, r12 \n\t"        \
+    "umaal r6, r7, r1, r12 \n\t"        \
+                                        \
+    "mov r12, #0 \n\t"                  \
+    "umaal r12, r4, r2, r14 \n\t"       \
+    "umaal r4, r5, r3, r14 \n\t"        \
+    "umaal r5, r6, r9, r14 \n\t"        \
+    "umaal r6, r7, r1, r14 \n\t"        \
+                                        \
+    /* Load carry from r10 */           \
+    "lsrs r10, #1 \n\t"                 \
+    "adcs r11, r11, r11 \n\t"           \
+    "adcs r12, r12, r12 \n\t"           \
+    "adc r10, r10, #0 \n\t"             \
+                                        \
+    /* Use carry from r8 */             \
+    "umaal r8, r11, r14, r14 \n\t"      \
+    "adds r11, r11, r12 \n\t"           \
+    "stmia r0!, {r8,r11} \n\t"          \
+    /* Store carry back in r8 */        \
+    "mov r8, #0 \n\t"                   \
+    "adc r8, r8, #0 \n\t"               \
+                                        \
+    "mov r11, #0 \n\t"                  \
+    "umaal r11, r5, r3, r2 \n\t"        \
+    "umaal r5, r6, r9, r2 \n\t"         \
+    "umaal r6, r7, r1, r2 \n\t"         \
+                                        \
+    "mov r12, #0 \n\t"                  \
+    "umaal r12, r6, r9, r3 \n\t"        \
+    "umaal r6, r7, r1, r3 \n\t"         \
+                                        \
+    "mov r14, #0 \n\t"                  \
+    "umaal r14, r7, r1, r9 \n\t"        \
+                                        \
+    /* Load carry from r10 */           \
+    "lsrs r10, #1 \n\t"                 \
+    "adcs r4, r4, r4 \n\t"              \
+    "adcs r11, r11, r11 \n\t"           \
+    "adcs r5, r5, r5 \n\t"              \
+    "adcs r12, r12, r12 \n\t"           \
+    "adcs r6, r6, r6 \n\t"              \
+    "adcs r14, r14, r14 \n\t"           \
+    "adcs r7, r7, r7 \n\t"              \
+    "adc r10, r10, #0 \n\t"             \
+                                        \
+    /* Use carry from r8 */             \
+    "umaal r4, r8, r2, r2 \n\t"         \
+    "adds r8, r8, r11 \n\t"             \
+    "stmia r0!, {r4,r8} \n\t"           \
+                                        \
+    "umull r4, r8, r3, r3 \n\t"         \
+    "adcs r4, r4, r5 \n\t"              \
+    "adcs r8, r8, r12 \n\t"             \
+    "stmia r0!, {r4,r8} \n\t"           \
+                                        \
+    "umull r4, r8, r9, r9 \n\t"         \
+    "adcs r4, r4, r6 \n\t"              \
+    "adcs r8, r8, r14 \n\t"             \
+    "stmia r0!, {r4,r8} \n\t"           \
+                                        \
+    "umull r4, r8, r1, r1 \n\t"         \
+    "adcs r4, r4, r7 \n\t"              \
+    "adcs r8, r8, r10 \n\t"             \
+    "stmia r0!, {r4,r8} \n\t"           \
+    /* TODO pop {r1, r2} if supporting curves > 256 bits */ \
+    "pop {r2} \n\t"
+
+#endif /* _UECC_ASM_ARM_MULT_SQUARE_H_ */
diff --git a/lib/micro-ecc/curve-specific.inc b/lib/micro-ecc/curve-specific.inc
new file mode 100644
index 00000000..0453b212
--- /dev/null
+++ b/lib/micro-ecc/curve-specific.inc
@@ -0,0 +1,1248 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_CURVE_SPECIFIC_H_
+#define _UECC_CURVE_SPECIFIC_H_
+
+#define num_bytes_secp160r1 20
+#define num_bytes_secp192r1 24
+#define num_bytes_secp224r1 28
+#define num_bytes_secp256r1 32
+#define num_bytes_secp256k1 32
+
+#if (uECC_WORD_SIZE == 1)
+
+#define num_words_secp160r1 20
+#define num_words_secp192r1 24
+#define num_words_secp224r1 28
+#define num_words_secp256r1 32
+#define num_words_secp256k1 32
+
+#define BYTES_TO_WORDS_8(a, b, c, d, e, f, g, h) \
+    0x##a, 0x##b, 0x##c, 0x##d, 0x##e, 0x##f, 0x##g, 0x##h
+#define BYTES_TO_WORDS_4(a, b, c, d) 0x##a, 0x##b, 0x##c, 0x##d
+
+#elif (uECC_WORD_SIZE == 4)
+
+#define num_words_secp160r1 5
+#define num_words_secp192r1 6
+#define num_words_secp224r1 7
+#define num_words_secp256r1 8
+#define num_words_secp256k1 8
+
+#define BYTES_TO_WORDS_8(a, b, c, d, e, f, g, h) 0x##d##c##b##a, 0x##h##g##f##e
+#define BYTES_TO_WORDS_4(a, b, c, d) 0x##d##c##b##a
+
+#elif (uECC_WORD_SIZE == 8)
+
+#define num_words_secp160r1 3
+#define num_words_secp192r1 3
+#define num_words_secp224r1 4
+#define num_words_secp256r1 4
+#define num_words_secp256k1 4
+
+#define BYTES_TO_WORDS_8(a, b, c, d, e, f, g, h) 0x##h##g##f##e##d##c##b##a##ull
+#define BYTES_TO_WORDS_4(a, b, c, d) 0x##d##c##b##a##ull
+
+#endif /* uECC_WORD_SIZE */
+
+#if uECC_SUPPORTS_secp160r1 || uECC_SUPPORTS_secp192r1 || \
+    uECC_SUPPORTS_secp224r1 || uECC_SUPPORTS_secp256r1
+static void double_jacobian_default(uECC_word_t * X1,
+                                    uECC_word_t * Y1,
+                                    uECC_word_t * Z1,
+                                    uECC_Curve curve) {
+    /* t1 = X, t2 = Y, t3 = Z */
+    uECC_word_t t4[uECC_MAX_WORDS];
+    uECC_word_t t5[uECC_MAX_WORDS];
+    wordcount_t num_words = curve->num_words;
+
+    if (uECC_vli_isZero(Z1, num_words)) {
+        return;
+    }
+
+    uECC_vli_modSquare_fast(t4, Y1, curve);   /* t4 = y1^2 */
+    uECC_vli_modMult_fast(t5, X1, t4, curve); /* t5 = x1*y1^2 = A */
+    uECC_vli_modSquare_fast(t4, t4, curve);   /* t4 = y1^4 */
+    uECC_vli_modMult_fast(Y1, Y1, Z1, curve); /* t2 = y1*z1 = z3 */
+    uECC_vli_modSquare_fast(Z1, Z1, curve);   /* t3 = z1^2 */
+
+    uECC_vli_modAdd(X1, X1, Z1, curve->p, num_words); /* t1 = x1 + z1^2 */
+    uECC_vli_modAdd(Z1, Z1, Z1, curve->p, num_words); /* t3 = 2*z1^2 */
+    uECC_vli_modSub(Z1, X1, Z1, curve->p, num_words); /* t3 = x1 - z1^2 */
+    uECC_vli_modMult_fast(X1, X1, Z1, curve);                /* t1 = x1^2 - z1^4 */
+
+    uECC_vli_modAdd(Z1, X1, X1, curve->p, num_words); /* t3 = 2*(x1^2 - z1^4) */
+    uECC_vli_modAdd(X1, X1, Z1, curve->p, num_words); /* t1 = 3*(x1^2 - z1^4) */
+    if (uECC_vli_testBit(X1, 0)) {
+        uECC_word_t l_carry = uECC_vli_add(X1, X1, curve->p, num_words);
+        uECC_vli_rshift1(X1, num_words);
+        X1[num_words - 1] |= l_carry << (uECC_WORD_BITS - 1);
+    } else {
+        uECC_vli_rshift1(X1, num_words);
+    }
+    /* t1 = 3/2*(x1^2 - z1^4) = B */
+
+    uECC_vli_modSquare_fast(Z1, X1, curve);                  /* t3 = B^2 */
+    uECC_vli_modSub(Z1, Z1, t5, curve->p, num_words); /* t3 = B^2 - A */
+    uECC_vli_modSub(Z1, Z1, t5, curve->p, num_words); /* t3 = B^2 - 2A = x3 */
+    uECC_vli_modSub(t5, t5, Z1, curve->p, num_words); /* t5 = A - x3 */
+    uECC_vli_modMult_fast(X1, X1, t5, curve);                /* t1 = B * (A - x3) */
+    uECC_vli_modSub(t4, X1, t4, curve->p, num_words); /* t4 = B * (A - x3) - y1^4 = y3 */
+
+    uECC_vli_set(X1, Z1, num_words);
+    uECC_vli_set(Z1, Y1, num_words);
+    uECC_vli_set(Y1, t4, num_words);
+}
+
+/* Computes result = x^3 + ax + b. result must not overlap x. */
+static void x_side_default(uECC_word_t *result, const uECC_word_t *x, uECC_Curve curve) {
+    uECC_word_t _3[uECC_MAX_WORDS] = {3}; /* -a = 3 */
+    wordcount_t num_words = curve->num_words;
+
+    uECC_vli_modSquare_fast(result, x, curve);                             /* r = x^2 */
+    uECC_vli_modSub(result, result, _3, curve->p, num_words);       /* r = x^2 - 3 */
+    uECC_vli_modMult_fast(result, result, x, curve);                       /* r = x^3 - 3x */
+    uECC_vli_modAdd(result, result, curve->b, curve->p, num_words); /* r = x^3 - 3x + b */
+}
+#endif /* uECC_SUPPORTS_secp... */
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+#if uECC_SUPPORTS_secp160r1 || uECC_SUPPORTS_secp192r1 || \
+    uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1
+/* Compute a = sqrt(a) (mod curve_p). */
+static void mod_sqrt_default(uECC_word_t *a, uECC_Curve curve) {
+    bitcount_t i;
+    uECC_word_t p1[uECC_MAX_WORDS] = {1};
+    uECC_word_t l_result[uECC_MAX_WORDS] = {1};
+    wordcount_t num_words = curve->num_words;
+    
+    /* When curve->p == 3 (mod 4), we can compute
+       sqrt(a) = a^((curve->p + 1) / 4) (mod curve->p). */
+    uECC_vli_add(p1, curve->p, p1, num_words); /* p1 = curve_p + 1 */
+    for (i = uECC_vli_numBits(p1, num_words) - 1; i > 1; --i) {
+        uECC_vli_modSquare_fast(l_result, l_result, curve);
+        if (uECC_vli_testBit(p1, i)) {
+            uECC_vli_modMult_fast(l_result, l_result, a, curve);
+        }
+    }
+    uECC_vli_set(a, l_result, num_words);
+}
+#endif /* uECC_SUPPORTS_secp... */
+#endif /* uECC_SUPPORT_COMPRESSED_POINT */
+
+#if uECC_SUPPORTS_secp160r1
+
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+static void vli_mmod_fast_secp160r1(uECC_word_t *result, uECC_word_t *product);
+#endif
+
+static const struct uECC_Curve_t curve_secp160r1 = {
+    num_words_secp160r1,
+    num_bytes_secp160r1,
+    161, /* num_n_bits */
+    { BYTES_TO_WORDS_8(FF, FF, FF, 7F, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_4(FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(57, 22, 75, CA, D3, AE, 27, F9),
+        BYTES_TO_WORDS_8(C8, F4, 01, 00, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, 01, 00, 00, 00) },
+    { BYTES_TO_WORDS_8(82, FC, CB, 13, B9, 8B, C3, 68),
+        BYTES_TO_WORDS_8(89, 69, 64, 46, 28, 73, F5, 8E),
+        BYTES_TO_WORDS_4(68, B5, 96, 4A),
+
+        BYTES_TO_WORDS_8(32, FB, C5, 7A, 37, 51, 23, 04),
+        BYTES_TO_WORDS_8(12, C9, DC, 59, 7D, 94, 68, 31),
+        BYTES_TO_WORDS_4(55, 28, A6, 23) },
+    { BYTES_TO_WORDS_8(45, FA, 65, C5, AD, D4, D4, 81),
+        BYTES_TO_WORDS_8(9F, F8, AC, 65, 8B, 7A, BD, 54),
+        BYTES_TO_WORDS_4(FC, BE, 97, 1C) },
+    &double_jacobian_default,
+#if uECC_SUPPORT_COMPRESSED_POINT
+    &mod_sqrt_default,
+#endif
+    &x_side_default,
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    &vli_mmod_fast_secp160r1
+#endif
+};
+
+uECC_Curve uECC_secp160r1(void) { return &curve_secp160r1; }
+
+#if (uECC_OPTIMIZATION_LEVEL > 0 && !asm_mmod_fast_secp160r1)
+/* Computes result = product % curve_p
+    see http://www.isys.uni-klu.ac.at/PDF/2001-0126-MT.pdf page 354
+    
+    Note that this only works if log2(omega) < log2(p) / 2 */
+static void omega_mult_secp160r1(uECC_word_t *result, const uECC_word_t *right);
+#if uECC_WORD_SIZE == 8
+static void vli_mmod_fast_secp160r1(uECC_word_t *result, uECC_word_t *product) {
+    uECC_word_t tmp[2 * num_words_secp160r1];
+    uECC_word_t copy;
+    
+    uECC_vli_clear(tmp, num_words_secp160r1);
+    uECC_vli_clear(tmp + num_words_secp160r1, num_words_secp160r1);
+
+    omega_mult_secp160r1(tmp, product + num_words_secp160r1 - 1); /* (Rq, q) = q * c */
+    
+    product[num_words_secp160r1 - 1] &= 0xffffffff;
+    copy = tmp[num_words_secp160r1 - 1];
+    tmp[num_words_secp160r1 - 1] &= 0xffffffff;
+    uECC_vli_add(result, product, tmp, num_words_secp160r1); /* (C, r) = r + q */
+    uECC_vli_clear(product, num_words_secp160r1);
+    tmp[num_words_secp160r1 - 1] = copy;
+    omega_mult_secp160r1(product, tmp + num_words_secp160r1 - 1); /* Rq*c */
+    uECC_vli_add(result, result, product, num_words_secp160r1); /* (C1, r) = r + Rq*c */
+
+    while (uECC_vli_cmp_unsafe(result, curve_secp160r1.p, num_words_secp160r1) > 0) {
+        uECC_vli_sub(result, result, curve_secp160r1.p, num_words_secp160r1);
+    }
+}
+
+static void omega_mult_secp160r1(uint64_t *result, const uint64_t *right) {
+    uint32_t carry;
+    unsigned i;
+    
+    /* Multiply by (2^31 + 1). */
+    carry = 0;
+    for (i = 0; i < num_words_secp160r1; ++i) {
+        uint64_t tmp = (right[i] >> 32) | (right[i + 1] << 32);
+        result[i] = (tmp << 31) + tmp + carry;
+        carry = (tmp >> 33) + (result[i] < tmp || (carry && result[i] == tmp));
+    }
+    result[i] = carry;
+}
+#else
+static void vli_mmod_fast_secp160r1(uECC_word_t *result, uECC_word_t *product) {
+    uECC_word_t tmp[2 * num_words_secp160r1];
+    uECC_word_t carry;
+    
+    uECC_vli_clear(tmp, num_words_secp160r1);
+    uECC_vli_clear(tmp + num_words_secp160r1, num_words_secp160r1);
+
+    omega_mult_secp160r1(tmp, product + num_words_secp160r1); /* (Rq, q) = q * c */
+    
+    carry = uECC_vli_add(result, product, tmp, num_words_secp160r1); /* (C, r) = r + q */
+    uECC_vli_clear(product, num_words_secp160r1);
+    omega_mult_secp160r1(product, tmp + num_words_secp160r1); /* Rq*c */
+    carry += uECC_vli_add(result, result, product, num_words_secp160r1); /* (C1, r) = r + Rq*c */
+
+    while (carry > 0) {
+        --carry;
+        uECC_vli_sub(result, result, curve_secp160r1.p, num_words_secp160r1);
+    }
+    if (uECC_vli_cmp_unsafe(result, curve_secp160r1.p, num_words_secp160r1) > 0) {
+        uECC_vli_sub(result, result, curve_secp160r1.p, num_words_secp160r1);
+    }
+}
+#endif
+
+#if uECC_WORD_SIZE == 1
+static void omega_mult_secp160r1(uint8_t *result, const uint8_t *right) {
+    uint8_t carry;
+    uint8_t i;
+    
+    /* Multiply by (2^31 + 1). */
+    uECC_vli_set(result + 4, right, num_words_secp160r1); /* 2^32 */
+    uECC_vli_rshift1(result + 4, num_words_secp160r1); /* 2^31 */
+    result[3] = right[0] << 7; /* get last bit from shift */
+    
+    carry = uECC_vli_add(result, result, right, num_words_secp160r1); /* 2^31 + 1 */
+    for (i = num_words_secp160r1; carry; ++i) {
+        uint16_t sum = (uint16_t)result[i] + carry;
+        result[i] = (uint8_t)sum;
+        carry = sum >> 8;
+    }
+}
+#elif uECC_WORD_SIZE == 4
+static void omega_mult_secp160r1(uint32_t *result, const uint32_t *right) {
+    uint32_t carry;
+    unsigned i;
+    
+    /* Multiply by (2^31 + 1). */
+    uECC_vli_set(result + 1, right, num_words_secp160r1); /* 2^32 */
+    uECC_vli_rshift1(result + 1, num_words_secp160r1); /* 2^31 */
+    result[0] = right[0] << 31; /* get last bit from shift */
+    
+    carry = uECC_vli_add(result, result, right, num_words_secp160r1); /* 2^31 + 1 */
+    for (i = num_words_secp160r1; carry; ++i) {
+        uint64_t sum = (uint64_t)result[i] + carry;
+        result[i] = (uint32_t)sum;
+        carry = sum >> 32;
+    }
+}
+#endif /* uECC_WORD_SIZE */
+#endif /* (uECC_OPTIMIZATION_LEVEL > 0 && !asm_mmod_fast_secp160r1) */
+
+#endif /* uECC_SUPPORTS_secp160r1 */
+
+#if uECC_SUPPORTS_secp192r1
+
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+static void vli_mmod_fast_secp192r1(uECC_word_t *result, uECC_word_t *product);
+#endif
+
+static const struct uECC_Curve_t curve_secp192r1 = {
+    num_words_secp192r1,
+    num_bytes_secp192r1,
+    192, /* num_n_bits */
+    { BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FE, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(31, 28, D2, B4, B1, C9, 6B, 14),
+        BYTES_TO_WORDS_8(36, F8, DE, 99, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(12, 10, FF, 82, FD, 0A, FF, F4),
+        BYTES_TO_WORDS_8(00, 88, A1, 43, EB, 20, BF, 7C),
+        BYTES_TO_WORDS_8(F6, 90, 30, B0, 0E, A8, 8D, 18),
+
+        BYTES_TO_WORDS_8(11, 48, 79, 1E, A1, 77, F9, 73),
+        BYTES_TO_WORDS_8(D5, CD, 24, 6B, ED, 11, 10, 63),
+        BYTES_TO_WORDS_8(78, DA, C8, FF, 95, 2B, 19, 07) },
+    { BYTES_TO_WORDS_8(B1, B9, 46, C1, EC, DE, B8, FE),
+        BYTES_TO_WORDS_8(49, 30, 24, 72, AB, E9, A7, 0F),
+        BYTES_TO_WORDS_8(E7, 80, 9C, E5, 19, 05, 21, 64) },
+    &double_jacobian_default,
+#if uECC_SUPPORT_COMPRESSED_POINT
+    &mod_sqrt_default,
+#endif
+    &x_side_default,
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    &vli_mmod_fast_secp192r1
+#endif
+};
+
+uECC_Curve uECC_secp192r1(void) { return &curve_secp192r1; }
+
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+/* Computes result = product % curve_p.
+   See algorithm 5 and 6 from http://www.isys.uni-klu.ac.at/PDF/2001-0126-MT.pdf */
+#if uECC_WORD_SIZE == 1
+static void vli_mmod_fast_secp192r1(uint8_t *result, uint8_t *product) {
+    uint8_t tmp[num_words_secp192r1];
+    uint8_t carry;
+    
+    uECC_vli_set(result, product, num_words_secp192r1);
+    
+    uECC_vli_set(tmp, &product[24], num_words_secp192r1);
+    carry = uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    tmp[0] = tmp[1] = tmp[2] = tmp[3] = tmp[4] = tmp[5] = tmp[6] = tmp[7] = 0;
+    tmp[8] = product[24]; tmp[9] = product[25]; tmp[10] = product[26]; tmp[11] = product[27];
+    tmp[12] = product[28]; tmp[13] = product[29]; tmp[14] = product[30]; tmp[15] = product[31];
+    tmp[16] = product[32]; tmp[17] = product[33]; tmp[18] = product[34]; tmp[19] = product[35];
+    tmp[20] = product[36]; tmp[21] = product[37]; tmp[22] = product[38]; tmp[23] = product[39];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    tmp[0] = tmp[8] = product[40];
+    tmp[1] = tmp[9] = product[41];
+    tmp[2] = tmp[10] = product[42];
+    tmp[3] = tmp[11] = product[43];
+    tmp[4] = tmp[12] = product[44];
+    tmp[5] = tmp[13] = product[45];
+    tmp[6] = tmp[14] = product[46];
+    tmp[7] = tmp[15] = product[47];
+    tmp[16] = tmp[17] = tmp[18] = tmp[19] = tmp[20] = tmp[21] = tmp[22] = tmp[23] = 0;
+    carry += uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    while (carry || uECC_vli_cmp_unsafe(curve_secp192r1.p, result, num_words_secp192r1) != 1) {
+        carry -= uECC_vli_sub(result, result, curve_secp192r1.p, num_words_secp192r1);
+    }
+}
+#elif uECC_WORD_SIZE == 4
+static void vli_mmod_fast_secp192r1(uint32_t *result, uint32_t *product) {
+    uint32_t tmp[num_words_secp192r1];
+    int carry;
+    
+    uECC_vli_set(result, product, num_words_secp192r1);
+    
+    uECC_vli_set(tmp, &product[6], num_words_secp192r1);
+    carry = uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    tmp[0] = tmp[1] = 0;
+    tmp[2] = product[6];
+    tmp[3] = product[7];
+    tmp[4] = product[8];
+    tmp[5] = product[9];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    tmp[0] = tmp[2] = product[10];
+    tmp[1] = tmp[3] = product[11];
+    tmp[4] = tmp[5] = 0;
+    carry += uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    while (carry || uECC_vli_cmp_unsafe(curve_secp192r1.p, result, num_words_secp192r1) != 1) {
+        carry -= uECC_vli_sub(result, result, curve_secp192r1.p, num_words_secp192r1);
+    }
+}
+#else
+static void vli_mmod_fast_secp192r1(uint64_t *result, uint64_t *product) {
+    uint64_t tmp[num_words_secp192r1];
+    int carry;
+    
+    uECC_vli_set(result, product, num_words_secp192r1);
+    
+    uECC_vli_set(tmp, &product[3], num_words_secp192r1);
+    carry = (int)uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    tmp[0] = 0;
+    tmp[1] = product[3];
+    tmp[2] = product[4];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    tmp[0] = tmp[1] = product[5];
+    tmp[2] = 0;
+    carry += uECC_vli_add(result, result, tmp, num_words_secp192r1);
+    
+    while (carry || uECC_vli_cmp_unsafe(curve_secp192r1.p, result, num_words_secp192r1) != 1) {
+        carry -= uECC_vli_sub(result, result, curve_secp192r1.p, num_words_secp192r1);
+    }
+}
+#endif /* uECC_WORD_SIZE */
+#endif /* (uECC_OPTIMIZATION_LEVEL > 0) */
+
+#endif /* uECC_SUPPORTS_secp192r1 */
+
+#if uECC_SUPPORTS_secp224r1
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+static void mod_sqrt_secp224r1(uECC_word_t *a, uECC_Curve curve);
+#endif
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+static void vli_mmod_fast_secp224r1(uECC_word_t *result, uECC_word_t *product);
+#endif
+
+static const struct uECC_Curve_t curve_secp224r1 = {
+    num_words_secp224r1,
+    num_bytes_secp224r1,
+    224, /* num_n_bits */
+    { BYTES_TO_WORDS_8(01, 00, 00, 00, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_4(FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(3D, 2A, 5C, 5C, 45, 29, DD, 13),
+        BYTES_TO_WORDS_8(3E, F0, B8, E0, A2, 16, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_4(FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(21, 1D, 5C, 11, D6, 80, 32, 34),
+        BYTES_TO_WORDS_8(22, 11, C2, 56, D3, C1, 03, 4A),
+        BYTES_TO_WORDS_8(B9, 90, 13, 32, 7F, BF, B4, 6B),
+        BYTES_TO_WORDS_4(BD, 0C, 0E, B7),
+
+        BYTES_TO_WORDS_8(34, 7E, 00, 85, 99, 81, D5, 44),
+        BYTES_TO_WORDS_8(64, 47, 07, 5A, A0, 75, 43, CD),
+        BYTES_TO_WORDS_8(E6, DF, 22, 4C, FB, 23, F7, B5),
+        BYTES_TO_WORDS_4(88, 63, 37, BD) },
+    { BYTES_TO_WORDS_8(B4, FF, 55, 23, 43, 39, 0B, 27),
+        BYTES_TO_WORDS_8(BA, D8, BF, D7, B7, B0, 44, 50),
+        BYTES_TO_WORDS_8(56, 32, 41, F5, AB, B3, 04, 0C),
+        BYTES_TO_WORDS_4(85, 0A, 05, B4) },
+    &double_jacobian_default,
+#if uECC_SUPPORT_COMPRESSED_POINT
+    &mod_sqrt_secp224r1,
+#endif
+    &x_side_default,
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    &vli_mmod_fast_secp224r1
+#endif
+};
+
+uECC_Curve uECC_secp224r1(void) { return &curve_secp224r1; }
+
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+/* Routine 3.2.4 RS;  from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+static void mod_sqrt_secp224r1_rs(uECC_word_t *d1,
+                                  uECC_word_t *e1,
+                                  uECC_word_t *f1,
+                                  const uECC_word_t *d0,
+                                  const uECC_word_t *e0,
+                                  const uECC_word_t *f0) {
+    uECC_word_t t[num_words_secp224r1];
+
+    uECC_vli_modSquare_fast(t, d0, &curve_secp224r1);                    /* t <-- d0 ^ 2 */
+    uECC_vli_modMult_fast(e1, d0, e0, &curve_secp224r1);                 /* e1 <-- d0 * e0 */
+    uECC_vli_modAdd(d1, t, f0, curve_secp224r1.p, num_words_secp224r1);  /* d1 <-- t  + f0 */
+    uECC_vli_modAdd(e1, e1, e1, curve_secp224r1.p, num_words_secp224r1); /* e1 <-- e1 + e1 */
+    uECC_vli_modMult_fast(f1, t, f0, &curve_secp224r1);                  /* f1 <-- t  * f0 */
+    uECC_vli_modAdd(f1, f1, f1, curve_secp224r1.p, num_words_secp224r1); /* f1 <-- f1 + f1 */
+    uECC_vli_modAdd(f1, f1, f1, curve_secp224r1.p, num_words_secp224r1); /* f1 <-- f1 + f1 */
+}
+
+/* Routine 3.2.5 RSS;  from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+static void mod_sqrt_secp224r1_rss(uECC_word_t *d1,
+                                   uECC_word_t *e1,
+                                   uECC_word_t *f1,
+                                   const uECC_word_t *d0,
+                                   const uECC_word_t *e0,
+                                   const uECC_word_t *f0,
+                                   const bitcount_t j) {
+    bitcount_t i;
+
+    uECC_vli_set(d1, d0, num_words_secp224r1); /* d1 <-- d0 */
+    uECC_vli_set(e1, e0, num_words_secp224r1); /* e1 <-- e0 */
+    uECC_vli_set(f1, f0, num_words_secp224r1); /* f1 <-- f0 */
+    for (i = 1; i <= j; i++) {
+        mod_sqrt_secp224r1_rs(d1, e1, f1, d1, e1, f1); /* RS (d1,e1,f1,d1,e1,f1) */
+    }
+}
+
+/* Routine 3.2.6 RM;  from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+static void mod_sqrt_secp224r1_rm(uECC_word_t *d2,
+                                  uECC_word_t *e2,
+                                  uECC_word_t *f2,
+                                  const uECC_word_t *c,
+                                  const uECC_word_t *d0,
+                                  const uECC_word_t *e0,
+                                  const uECC_word_t *d1,
+                                  const uECC_word_t *e1) {
+    uECC_word_t t1[num_words_secp224r1];
+    uECC_word_t t2[num_words_secp224r1];
+
+    uECC_vli_modMult_fast(t1, e0, e1, &curve_secp224r1); /* t1 <-- e0 * e1 */
+    uECC_vli_modMult_fast(t1, t1, c, &curve_secp224r1);  /* t1 <-- t1 * c */
+    /* t1 <-- p  - t1 */
+    uECC_vli_modSub(t1, curve_secp224r1.p, t1, curve_secp224r1.p, num_words_secp224r1);
+    uECC_vli_modMult_fast(t2, d0, d1, &curve_secp224r1);                 /* t2 <-- d0 * d1 */
+    uECC_vli_modAdd(t2, t2, t1, curve_secp224r1.p, num_words_secp224r1); /* t2 <-- t2 + t1 */
+    uECC_vli_modMult_fast(t1, d0, e1, &curve_secp224r1);                 /* t1 <-- d0 * e1 */
+    uECC_vli_modMult_fast(e2, d1, e0, &curve_secp224r1);                 /* e2 <-- d1 * e0 */
+    uECC_vli_modAdd(e2, e2, t1, curve_secp224r1.p, num_words_secp224r1); /* e2 <-- e2 + t1 */
+    uECC_vli_modSquare_fast(f2, e2, &curve_secp224r1);                   /* f2 <-- e2^2 */
+    uECC_vli_modMult_fast(f2, f2, c, &curve_secp224r1);                  /* f2 <-- f2 * c */
+    /* f2 <-- p  - f2 */
+    uECC_vli_modSub(f2, curve_secp224r1.p, f2, curve_secp224r1.p, num_words_secp224r1);
+    uECC_vli_set(d2, t2, num_words_secp224r1); /* d2 <-- t2 */
+}
+
+/* Routine 3.2.7 RP;  from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+static void mod_sqrt_secp224r1_rp(uECC_word_t *d1,
+                                  uECC_word_t *e1,
+                                  uECC_word_t *f1,
+                                  const uECC_word_t *c,
+                                  const uECC_word_t *r) {
+    wordcount_t i;
+    wordcount_t pow2i = 1;
+    uECC_word_t d0[num_words_secp224r1];
+    uECC_word_t e0[num_words_secp224r1] = {1}; /* e0 <-- 1 */
+    uECC_word_t f0[num_words_secp224r1];
+
+    uECC_vli_set(d0, r, num_words_secp224r1); /* d0 <-- r */
+    /* f0 <-- p  - c */
+    uECC_vli_modSub(f0, curve_secp224r1.p, c, curve_secp224r1.p, num_words_secp224r1);
+    for (i = 0; i <= 6; i++) {
+        mod_sqrt_secp224r1_rss(d1, e1, f1, d0, e0, f0, pow2i); /* RSS (d1,e1,f1,d0,e0,f0,2^i) */
+        mod_sqrt_secp224r1_rm(d1, e1, f1, c, d1, e1, d0, e0);  /* RM (d1,e1,f1,c,d1,e1,d0,e0) */
+        uECC_vli_set(d0, d1, num_words_secp224r1); /* d0 <-- d1 */
+        uECC_vli_set(e0, e1, num_words_secp224r1); /* e0 <-- e1 */
+        uECC_vli_set(f0, f1, num_words_secp224r1); /* f0 <-- f1 */
+        pow2i *= 2;
+    }
+}
+
+/* Compute a = sqrt(a) (mod curve_p). */
+/* Routine 3.2.8 mp_mod_sqrt_224; from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+static void mod_sqrt_secp224r1(uECC_word_t *a, uECC_Curve curve) {
+    bitcount_t i;
+    uECC_word_t e1[num_words_secp224r1];
+    uECC_word_t f1[num_words_secp224r1];
+    uECC_word_t d0[num_words_secp224r1];
+    uECC_word_t e0[num_words_secp224r1];
+    uECC_word_t f0[num_words_secp224r1];
+    uECC_word_t d1[num_words_secp224r1];
+
+    /* s = a; using constant instead of random value */
+    mod_sqrt_secp224r1_rp(d0, e0, f0, a, a);           /* RP (d0, e0, f0, c, s) */
+    mod_sqrt_secp224r1_rs(d1, e1, f1, d0, e0, f0);     /* RS (d1, e1, f1, d0, e0, f0) */
+    for (i = 1; i <= 95; i++) {
+        uECC_vli_set(d0, d1, num_words_secp224r1);          /* d0 <-- d1 */
+        uECC_vli_set(e0, e1, num_words_secp224r1);          /* e0 <-- e1 */
+        uECC_vli_set(f0, f1, num_words_secp224r1);          /* f0 <-- f1 */
+        mod_sqrt_secp224r1_rs(d1, e1, f1, d0, e0, f0); /* RS (d1, e1, f1, d0, e0, f0) */
+        if (uECC_vli_isZero(d1, num_words_secp224r1)) {     /* if d1 == 0 */
+                break;
+        }
+    }
+    uECC_vli_modInv(f1, e0, curve_secp224r1.p, num_words_secp224r1); /* f1 <-- 1 / e0 */
+    uECC_vli_modMult_fast(a, d0, f1, &curve_secp224r1);              /* a  <-- d0 / e0 */
+}
+#endif /* uECC_SUPPORT_COMPRESSED_POINT */
+
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+/* Computes result = product % curve_p
+   from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+#if uECC_WORD_SIZE == 1
+static void vli_mmod_fast_secp224r1(uint8_t *result, uint8_t *product) {
+    uint8_t tmp[num_words_secp224r1];
+    int8_t carry;
+
+    /* t */
+    uECC_vli_set(result, product, num_words_secp224r1);
+
+    /* s1 */
+    tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
+    tmp[4] = tmp[5] = tmp[6] = tmp[7] = 0;
+    tmp[8] = tmp[9] = tmp[10] = tmp[11] = 0;
+    tmp[12] = product[28]; tmp[13] = product[29]; tmp[14] = product[30]; tmp[15] = product[31];
+    tmp[16] = product[32]; tmp[17] = product[33]; tmp[18] = product[34]; tmp[19] = product[35];
+    tmp[20] = product[36]; tmp[21] = product[37]; tmp[22] = product[38]; tmp[23] = product[39];
+    tmp[24] = product[40]; tmp[25] = product[41]; tmp[26] = product[42]; tmp[27] = product[43];
+    carry = uECC_vli_add(result, result, tmp, num_words_secp224r1);
+
+    /* s2 */
+    tmp[12] = product[44]; tmp[13] = product[45]; tmp[14] = product[46]; tmp[15] = product[47];
+    tmp[16] = product[48]; tmp[17] = product[49]; tmp[18] = product[50]; tmp[19] = product[51];
+    tmp[20] = product[52]; tmp[21] = product[53]; tmp[22] = product[54]; tmp[23] = product[55];
+    tmp[24] = tmp[25] = tmp[26] = tmp[27] = 0;
+    carry += uECC_vli_add(result, result, tmp, num_words_secp224r1);
+
+    /* d1 */
+    tmp[0]  = product[28]; tmp[1]  = product[29]; tmp[2]  = product[30]; tmp[3]  = product[31];
+    tmp[4]  = product[32]; tmp[5]  = product[33]; tmp[6]  = product[34]; tmp[7]  = product[35];
+    tmp[8]  = product[36]; tmp[9]  = product[37]; tmp[10] = product[38]; tmp[11] = product[39];
+    tmp[12] = product[40]; tmp[13] = product[41]; tmp[14] = product[42]; tmp[15] = product[43];
+    tmp[16] = product[44]; tmp[17] = product[45]; tmp[18] = product[46]; tmp[19] = product[47];
+    tmp[20] = product[48]; tmp[21] = product[49]; tmp[22] = product[50]; tmp[23] = product[51];
+    tmp[24] = product[52]; tmp[25] = product[53]; tmp[26] = product[54]; tmp[27] = product[55];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp224r1);
+
+    /* d2 */
+    tmp[0]  = product[44]; tmp[1]  = product[45]; tmp[2]  = product[46]; tmp[3]  = product[47];
+    tmp[4]  = product[48]; tmp[5]  = product[49]; tmp[6]  = product[50]; tmp[7]  = product[51];
+    tmp[8]  = product[52]; tmp[9]  = product[53]; tmp[10] = product[54]; tmp[11] = product[55];
+    tmp[12] = tmp[13] = tmp[14] = tmp[15] = 0;
+    tmp[16] = tmp[17] = tmp[18] = tmp[19] = 0;
+    tmp[20] = tmp[21] = tmp[22] = tmp[23] = 0;
+    tmp[24] = tmp[25] = tmp[26] = tmp[27] = 0;
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp224r1);
+
+    if (carry < 0) {
+        do {
+            carry += uECC_vli_add(result, result, curve_secp224r1.p, num_words_secp224r1);
+        } while (carry < 0);
+    } else {
+        while (carry || uECC_vli_cmp_unsafe(curve_secp224r1.p, result, num_words_secp224r1) != 1) {
+            carry -= uECC_vli_sub(result, result, curve_secp224r1.p, num_words_secp224r1);
+        }
+    }
+}
+#elif uECC_WORD_SIZE == 4
+static void vli_mmod_fast_secp224r1(uint32_t *result, uint32_t *product)
+{
+    uint32_t tmp[num_words_secp224r1];
+    int carry;
+
+    /* t */
+    uECC_vli_set(result, product, num_words_secp224r1);
+
+    /* s1 */
+    tmp[0] = tmp[1] = tmp[2] = 0;
+    tmp[3] = product[7];
+    tmp[4] = product[8];
+    tmp[5] = product[9];
+    tmp[6] = product[10];
+    carry = uECC_vli_add(result, result, tmp, num_words_secp224r1);
+
+    /* s2 */
+    tmp[3] = product[11];
+    tmp[4] = product[12];
+    tmp[5] = product[13];
+    tmp[6] = 0;
+    carry += uECC_vli_add(result, result, tmp, num_words_secp224r1);
+
+    /* d1 */
+    tmp[0] = product[7];
+    tmp[1] = product[8];
+    tmp[2] = product[9];
+    tmp[3] = product[10];
+    tmp[4] = product[11];
+    tmp[5] = product[12];
+    tmp[6] = product[13];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp224r1);
+
+    /* d2 */
+    tmp[0] = product[11];
+    tmp[1] = product[12];
+    tmp[2] = product[13];
+    tmp[3] = tmp[4] = tmp[5] = tmp[6] = 0;
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp224r1);
+
+    if (carry < 0) {
+        do {
+            carry += uECC_vli_add(result, result, curve_secp224r1.p, num_words_secp224r1);
+        } while (carry < 0);
+    } else {
+        while (carry || uECC_vli_cmp_unsafe(curve_secp224r1.p, result, num_words_secp224r1) != 1) {
+            carry -= uECC_vli_sub(result, result, curve_secp224r1.p, num_words_secp224r1);
+        }
+    }
+}
+#else
+static void vli_mmod_fast_secp224r1(uint64_t *result, uint64_t *product)
+{
+    uint64_t tmp[num_words_secp224r1];
+    int carry = 0;
+
+    /* t */
+    uECC_vli_set(result, product, num_words_secp224r1);
+    result[num_words_secp224r1 - 1] &= 0xffffffff;
+
+    /* s1 */
+    tmp[0] = 0;
+    tmp[1] = product[3] & 0xffffffff00000000ull;
+    tmp[2] = product[4];
+    tmp[3] = product[5] & 0xffffffff;
+    uECC_vli_add(result, result, tmp, num_words_secp224r1);
+
+    /* s2 */
+    tmp[1] = product[5] & 0xffffffff00000000ull;
+    tmp[2] = product[6];
+    tmp[3] = 0;
+    uECC_vli_add(result, result, tmp, num_words_secp224r1);
+
+    /* d1 */
+    tmp[0] = (product[3] >> 32) | (product[4] << 32);
+    tmp[1] = (product[4] >> 32) | (product[5] << 32);
+    tmp[2] = (product[5] >> 32) | (product[6] << 32);
+    tmp[3] = product[6] >> 32;
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp224r1);
+
+    /* d2 */
+    tmp[0] = (product[5] >> 32) | (product[6] << 32);
+    tmp[1] = product[6] >> 32;
+    tmp[2] = tmp[3] = 0;
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp224r1);
+
+    if (carry < 0) {
+        do {
+            carry += uECC_vli_add(result, result, curve_secp224r1.p, num_words_secp224r1);
+        } while (carry < 0);
+    } else {
+        while (uECC_vli_cmp_unsafe(curve_secp224r1.p, result, num_words_secp224r1) != 1) {
+            uECC_vli_sub(result, result, curve_secp224r1.p, num_words_secp224r1);
+        }
+    }
+}
+#endif /* uECC_WORD_SIZE */
+#endif /* (uECC_OPTIMIZATION_LEVEL > 0) */
+
+#endif /* uECC_SUPPORTS_secp224r1 */
+
+#if uECC_SUPPORTS_secp256r1
+
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+static void vli_mmod_fast_secp256r1(uECC_word_t *result, uECC_word_t *product);
+#endif
+
+static const struct uECC_Curve_t curve_secp256r1 = {
+    num_words_secp256r1,
+    num_bytes_secp256r1,
+    256, /* num_n_bits */
+    { BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(01, 00, 00, 00, FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(51, 25, 63, FC, C2, CA, B9, F3),
+        BYTES_TO_WORDS_8(84, 9E, 17, A7, AD, FA, E6, BC),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(96, C2, 98, D8, 45, 39, A1, F4),
+        BYTES_TO_WORDS_8(A0, 33, EB, 2D, 81, 7D, 03, 77),
+        BYTES_TO_WORDS_8(F2, 40, A4, 63, E5, E6, BC, F8),
+        BYTES_TO_WORDS_8(47, 42, 2C, E1, F2, D1, 17, 6B),
+
+        BYTES_TO_WORDS_8(F5, 51, BF, 37, 68, 40, B6, CB),
+        BYTES_TO_WORDS_8(CE, 5E, 31, 6B, 57, 33, CE, 2B),
+        BYTES_TO_WORDS_8(16, 9E, 0F, 7C, 4A, EB, E7, 8E),
+        BYTES_TO_WORDS_8(9B, 7F, 1A, FE, E2, 42, E3, 4F) },
+    { BYTES_TO_WORDS_8(4B, 60, D2, 27, 3E, 3C, CE, 3B),
+        BYTES_TO_WORDS_8(F6, B0, 53, CC, B0, 06, 1D, 65),
+        BYTES_TO_WORDS_8(BC, 86, 98, 76, 55, BD, EB, B3),
+        BYTES_TO_WORDS_8(E7, 93, 3A, AA, D8, 35, C6, 5A) },
+    &double_jacobian_default,
+#if uECC_SUPPORT_COMPRESSED_POINT
+    &mod_sqrt_default,
+#endif
+    &x_side_default,
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    &vli_mmod_fast_secp256r1
+#endif
+};
+
+uECC_Curve uECC_secp256r1(void) { return &curve_secp256r1; }
+
+
+#if (uECC_OPTIMIZATION_LEVEL > 0 && !asm_mmod_fast_secp256r1)
+/* Computes result = product % curve_p
+   from http://www.nsa.gov/ia/_files/nist-routines.pdf */
+#if uECC_WORD_SIZE == 1
+static void vli_mmod_fast_secp256r1(uint8_t *result, uint8_t *product) {
+    uint8_t tmp[num_words_secp256r1];
+    int8_t carry;
+    
+    /* t */
+    uECC_vli_set(result, product, num_words_secp256r1);
+    
+    /* s1 */
+    tmp[0] = tmp[1] = tmp[2] = tmp[3] = 0;
+    tmp[4] = tmp[5] = tmp[6] = tmp[7] = 0;
+    tmp[8] = tmp[9] = tmp[10] = tmp[11] = 0;
+    tmp[12] = product[44]; tmp[13] = product[45]; tmp[14] = product[46]; tmp[15] = product[47];
+    tmp[16] = product[48]; tmp[17] = product[49]; tmp[18] = product[50]; tmp[19] = product[51];
+    tmp[20] = product[52]; tmp[21] = product[53]; tmp[22] = product[54]; tmp[23] = product[55];
+    tmp[24] = product[56]; tmp[25] = product[57]; tmp[26] = product[58]; tmp[27] = product[59];
+    tmp[28] = product[60]; tmp[29] = product[61]; tmp[30] = product[62]; tmp[31] = product[63];
+    carry = uECC_vli_add(tmp, tmp, tmp, num_words_secp256r1);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s2 */
+    tmp[12] = product[48]; tmp[13] = product[49]; tmp[14] = product[50]; tmp[15] = product[51];
+    tmp[16] = product[52]; tmp[17] = product[53]; tmp[18] = product[54]; tmp[19] = product[55];
+    tmp[20] = product[56]; tmp[21] = product[57]; tmp[22] = product[58]; tmp[23] = product[59];
+    tmp[24] = product[60]; tmp[25] = product[61]; tmp[26] = product[62]; tmp[27] = product[63];
+    tmp[28] = tmp[29] = tmp[30] = tmp[31] = 0;
+    carry += uECC_vli_add(tmp, tmp, tmp, num_words_secp256r1);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s3 */
+    tmp[0] = product[32]; tmp[1] = product[33]; tmp[2] = product[34]; tmp[3] = product[35];
+    tmp[4] = product[36]; tmp[5] = product[37]; tmp[6] = product[38]; tmp[7] = product[39];
+    tmp[8] = product[40]; tmp[9] = product[41]; tmp[10] = product[42]; tmp[11] = product[43];
+    tmp[12] = tmp[13] = tmp[14] = tmp[15] = 0;
+    tmp[16] = tmp[17] = tmp[18] = tmp[19] = 0;
+    tmp[20] = tmp[21] = tmp[22] = tmp[23] = 0;
+    tmp[24] = product[56]; tmp[25] = product[57]; tmp[26] = product[58]; tmp[27] = product[59];
+    tmp[28] = product[60]; tmp[29] = product[61]; tmp[30] = product[62]; tmp[31] = product[63];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s4 */
+    tmp[0] = product[36]; tmp[1] = product[37]; tmp[2] = product[38]; tmp[3] = product[39];
+    tmp[4] = product[40]; tmp[5] = product[41]; tmp[6] = product[42]; tmp[7] = product[43];
+    tmp[8] = product[44]; tmp[9] = product[45]; tmp[10] = product[46]; tmp[11] = product[47];
+    tmp[12] = product[52]; tmp[13] = product[53]; tmp[14] = product[54]; tmp[15] = product[55];
+    tmp[16] = product[56]; tmp[17] = product[57]; tmp[18] = product[58]; tmp[19] = product[59];
+    tmp[20] = product[60]; tmp[21] = product[61]; tmp[22] = product[62]; tmp[23] = product[63];
+    tmp[24] = product[52]; tmp[25] = product[53]; tmp[26] = product[54]; tmp[27] = product[55];
+    tmp[28] = product[32]; tmp[29] = product[33]; tmp[30] = product[34]; tmp[31] = product[35];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* d1 */
+    tmp[0] = product[44]; tmp[1] = product[45]; tmp[2] = product[46]; tmp[3] = product[47];
+    tmp[4] = product[48]; tmp[5] = product[49]; tmp[6] = product[50]; tmp[7] = product[51];
+    tmp[8] = product[52]; tmp[9] = product[53]; tmp[10] = product[54]; tmp[11] = product[55];
+    tmp[12] = tmp[13] = tmp[14] = tmp[15] = 0;
+    tmp[16] = tmp[17] = tmp[18] = tmp[19] = 0;
+    tmp[20] = tmp[21] = tmp[22] = tmp[23] = 0;
+    tmp[24] = product[32]; tmp[25] = product[33]; tmp[26] = product[34]; tmp[27] = product[35];
+    tmp[28] = product[40]; tmp[29] = product[41]; tmp[30] = product[42]; tmp[31] = product[43];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d2 */
+    tmp[0] = product[48]; tmp[1] = product[49]; tmp[2] = product[50]; tmp[3] = product[51];
+    tmp[4] = product[52]; tmp[5] = product[53]; tmp[6] = product[54]; tmp[7] = product[55];
+    tmp[8] = product[56]; tmp[9] = product[57]; tmp[10] = product[58]; tmp[11] = product[59];
+    tmp[12] = product[60]; tmp[13] = product[61]; tmp[14] = product[62]; tmp[15] = product[63];
+    tmp[16] = tmp[17] = tmp[18] = tmp[19] = 0;
+    tmp[20] = tmp[21] = tmp[22] = tmp[23] = 0;
+    tmp[24] = product[36]; tmp[25] = product[37]; tmp[26] = product[38]; tmp[27] = product[39];
+    tmp[28] = product[44]; tmp[29] = product[45]; tmp[30] = product[46]; tmp[31] = product[47];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d3 */
+    tmp[0] = product[52]; tmp[1] = product[53]; tmp[2] = product[54]; tmp[3] = product[55];
+    tmp[4] = product[56]; tmp[5] = product[57]; tmp[6] = product[58]; tmp[7] = product[59];
+    tmp[8] = product[60]; tmp[9] = product[61]; tmp[10] = product[62]; tmp[11] = product[63];
+    tmp[12] = product[32]; tmp[13] = product[33]; tmp[14] = product[34]; tmp[15] = product[35];
+    tmp[16] = product[36]; tmp[17] = product[37]; tmp[18] = product[38]; tmp[19] = product[39];
+    tmp[20] = product[40]; tmp[21] = product[41]; tmp[22] = product[42]; tmp[23] = product[43];
+    tmp[24] = tmp[25] = tmp[26] = tmp[27] = 0;
+    tmp[28] = product[48]; tmp[29] = product[49]; tmp[30] = product[50]; tmp[31] = product[51];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d4 */
+    tmp[0] = product[56]; tmp[1] = product[57]; tmp[2] = product[58]; tmp[3] = product[59];
+    tmp[4] = product[60]; tmp[5] = product[61]; tmp[6] = product[62]; tmp[7] = product[63];
+    tmp[8] = tmp[9] = tmp[10] = tmp[11] = 0;
+    tmp[12] = product[36]; tmp[13] = product[37]; tmp[14] = product[38]; tmp[15] = product[39];
+    tmp[16] = product[40]; tmp[17] = product[41]; tmp[18] = product[42]; tmp[19] = product[43];
+    tmp[20] = product[44]; tmp[21] = product[45]; tmp[22] = product[46]; tmp[23] = product[47];
+    tmp[24] = tmp[25] = tmp[26] = tmp[27] = 0;
+    tmp[28] = product[52]; tmp[29] = product[53]; tmp[30] = product[54]; tmp[31] = product[55];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    if (carry < 0) {
+        do {
+            carry += uECC_vli_add(result, result, curve_secp256r1.p, num_words_secp256r1);
+        } while (carry < 0);
+    } else {
+        while (carry || uECC_vli_cmp_unsafe(curve_secp256r1.p, result, num_words_secp256r1) != 1) {
+            carry -= uECC_vli_sub(result, result, curve_secp256r1.p, num_words_secp256r1);
+        }
+    }
+}
+#elif uECC_WORD_SIZE == 4
+static void vli_mmod_fast_secp256r1(uint32_t *result, uint32_t *product) {
+    uint32_t tmp[num_words_secp256r1];
+    int carry;
+    
+    /* t */
+    uECC_vli_set(result, product, num_words_secp256r1);
+    
+    /* s1 */
+    tmp[0] = tmp[1] = tmp[2] = 0;
+    tmp[3] = product[11];
+    tmp[4] = product[12];
+    tmp[5] = product[13];
+    tmp[6] = product[14];
+    tmp[7] = product[15];
+    carry = uECC_vli_add(tmp, tmp, tmp, num_words_secp256r1);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s2 */
+    tmp[3] = product[12];
+    tmp[4] = product[13];
+    tmp[5] = product[14];
+    tmp[6] = product[15];
+    tmp[7] = 0;
+    carry += uECC_vli_add(tmp, tmp, tmp, num_words_secp256r1);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s3 */
+    tmp[0] = product[8];
+    tmp[1] = product[9];
+    tmp[2] = product[10];
+    tmp[3] = tmp[4] = tmp[5] = 0;
+    tmp[6] = product[14];
+    tmp[7] = product[15];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s4 */
+    tmp[0] = product[9];
+    tmp[1] = product[10];
+    tmp[2] = product[11];
+    tmp[3] = product[13];
+    tmp[4] = product[14];
+    tmp[5] = product[15];
+    tmp[6] = product[13];
+    tmp[7] = product[8];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* d1 */
+    tmp[0] = product[11];
+    tmp[1] = product[12];
+    tmp[2] = product[13];
+    tmp[3] = tmp[4] = tmp[5] = 0;
+    tmp[6] = product[8];
+    tmp[7] = product[10];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d2 */
+    tmp[0] = product[12];
+    tmp[1] = product[13];
+    tmp[2] = product[14];
+    tmp[3] = product[15];
+    tmp[4] = tmp[5] = 0;
+    tmp[6] = product[9];
+    tmp[7] = product[11];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d3 */
+    tmp[0] = product[13];
+    tmp[1] = product[14];
+    tmp[2] = product[15];
+    tmp[3] = product[8];
+    tmp[4] = product[9];
+    tmp[5] = product[10];
+    tmp[6] = 0;
+    tmp[7] = product[12];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d4 */
+    tmp[0] = product[14];
+    tmp[1] = product[15];
+    tmp[2] = 0;
+    tmp[3] = product[9];
+    tmp[4] = product[10];
+    tmp[5] = product[11];
+    tmp[6] = 0;
+    tmp[7] = product[13];
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    if (carry < 0) {
+        do {
+            carry += uECC_vli_add(result, result, curve_secp256r1.p, num_words_secp256r1);
+        } while (carry < 0);
+    } else {
+        while (carry || uECC_vli_cmp_unsafe(curve_secp256r1.p, result, num_words_secp256r1) != 1) {
+            carry -= uECC_vli_sub(result, result, curve_secp256r1.p, num_words_secp256r1);
+        }
+    }
+}
+#else
+static void vli_mmod_fast_secp256r1(uint64_t *result, uint64_t *product) {
+    uint64_t tmp[num_words_secp256r1];
+    int carry;
+    
+    /* t */
+    uECC_vli_set(result, product, num_words_secp256r1);
+    
+    /* s1 */
+    tmp[0] = 0;
+    tmp[1] = product[5] & 0xffffffff00000000ull;
+    tmp[2] = product[6];
+    tmp[3] = product[7];
+    carry = (int)uECC_vli_add(tmp, tmp, tmp, num_words_secp256r1);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s2 */
+    tmp[1] = product[6] << 32;
+    tmp[2] = (product[6] >> 32) | (product[7] << 32);
+    tmp[3] = product[7] >> 32;
+    carry += uECC_vli_add(tmp, tmp, tmp, num_words_secp256r1);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s3 */
+    tmp[0] = product[4];
+    tmp[1] = product[5] & 0xffffffff;
+    tmp[2] = 0;
+    tmp[3] = product[7];
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* s4 */
+    tmp[0] = (product[4] >> 32) | (product[5] << 32);
+    tmp[1] = (product[5] >> 32) | (product[6] & 0xffffffff00000000ull);
+    tmp[2] = product[7];
+    tmp[3] = (product[6] >> 32) | (product[4] << 32);
+    carry += uECC_vli_add(result, result, tmp, num_words_secp256r1);
+    
+    /* d1 */
+    tmp[0] = (product[5] >> 32) | (product[6] << 32);
+    tmp[1] = (product[6] >> 32);
+    tmp[2] = 0;
+    tmp[3] = (product[4] & 0xffffffff) | (product[5] << 32);
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d2 */
+    tmp[0] = product[6];
+    tmp[1] = product[7];
+    tmp[2] = 0;
+    tmp[3] = (product[4] >> 32) | (product[5] & 0xffffffff00000000ull);
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d3 */
+    tmp[0] = (product[6] >> 32) | (product[7] << 32);
+    tmp[1] = (product[7] >> 32) | (product[4] << 32);
+    tmp[2] = (product[4] >> 32) | (product[5] << 32);
+    tmp[3] = (product[6] << 32);
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    /* d4 */
+    tmp[0] = product[7];
+    tmp[1] = product[4] & 0xffffffff00000000ull;
+    tmp[2] = product[5];
+    tmp[3] = product[6] & 0xffffffff00000000ull;
+    carry -= uECC_vli_sub(result, result, tmp, num_words_secp256r1);
+    
+    if (carry < 0) {
+        do {
+            carry += uECC_vli_add(result, result, curve_secp256r1.p, num_words_secp256r1);
+        } while (carry < 0);
+    } else {
+        while (carry || uECC_vli_cmp_unsafe(curve_secp256r1.p, result, num_words_secp256r1) != 1) {
+            carry -= uECC_vli_sub(result, result, curve_secp256r1.p, num_words_secp256r1);
+        }
+    }
+}
+#endif /* uECC_WORD_SIZE */
+#endif /* (uECC_OPTIMIZATION_LEVEL > 0 && !asm_mmod_fast_secp256r1) */
+
+#endif /* uECC_SUPPORTS_secp256r1 */
+
+#if uECC_SUPPORTS_secp256k1
+
+static void double_jacobian_secp256k1(uECC_word_t * X1,
+                                      uECC_word_t * Y1,
+                                      uECC_word_t * Z1,
+                                      uECC_Curve curve);
+static void x_side_secp256k1(uECC_word_t *result, const uECC_word_t *x, uECC_Curve curve);
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+static void vli_mmod_fast_secp256k1(uECC_word_t *result, uECC_word_t *product);
+#endif
+
+static const struct uECC_Curve_t curve_secp256k1 = {
+    num_words_secp256k1,
+    num_bytes_secp256k1,
+    256, /* num_n_bits */
+    { BYTES_TO_WORDS_8(2F, FC, FF, FF, FE, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(41, 41, 36, D0, 8C, 5E, D2, BF),
+        BYTES_TO_WORDS_8(3B, A0, 48, AF, E6, DC, AE, BA),
+        BYTES_TO_WORDS_8(FE, FF, FF, FF, FF, FF, FF, FF),
+        BYTES_TO_WORDS_8(FF, FF, FF, FF, FF, FF, FF, FF) },
+    { BYTES_TO_WORDS_8(98, 17, F8, 16, 5B, 81, F2, 59),
+        BYTES_TO_WORDS_8(D9, 28, CE, 2D, DB, FC, 9B, 02),
+        BYTES_TO_WORDS_8(07, 0B, 87, CE, 95, 62, A0, 55),
+        BYTES_TO_WORDS_8(AC, BB, DC, F9, 7E, 66, BE, 79),
+
+        BYTES_TO_WORDS_8(B8, D4, 10, FB, 8F, D0, 47, 9C),
+        BYTES_TO_WORDS_8(19, 54, 85, A6, 48, B4, 17, FD),
+        BYTES_TO_WORDS_8(A8, 08, 11, 0E, FC, FB, A4, 5D),
+        BYTES_TO_WORDS_8(65, C4, A3, 26, 77, DA, 3A, 48) },
+    { BYTES_TO_WORDS_8(07, 00, 00, 00, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, 00, 00, 00, 00),
+        BYTES_TO_WORDS_8(00, 00, 00, 00, 00, 00, 00, 00) },
+    &double_jacobian_secp256k1,
+#if uECC_SUPPORT_COMPRESSED_POINT
+    &mod_sqrt_default,
+#endif
+    &x_side_secp256k1,
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    &vli_mmod_fast_secp256k1
+#endif
+};
+
+uECC_Curve uECC_secp256k1(void) { return &curve_secp256k1; }
+
+
+/* Double in place */
+static void double_jacobian_secp256k1(uECC_word_t * X1,
+                                      uECC_word_t * Y1,
+                                      uECC_word_t * Z1,
+                                      uECC_Curve curve) {
+    /* t1 = X, t2 = Y, t3 = Z */
+    uECC_word_t t4[num_words_secp256k1];
+    uECC_word_t t5[num_words_secp256k1];
+    
+    if (uECC_vli_isZero(Z1, num_words_secp256k1)) {
+        return;
+    }
+    
+    uECC_vli_modSquare_fast(t5, Y1, curve);   /* t5 = y1^2 */
+    uECC_vli_modMult_fast(t4, X1, t5, curve); /* t4 = x1*y1^2 = A */
+    uECC_vli_modSquare_fast(X1, X1, curve);   /* t1 = x1^2 */
+    uECC_vli_modSquare_fast(t5, t5, curve);   /* t5 = y1^4 */
+    uECC_vli_modMult_fast(Z1, Y1, Z1, curve); /* t3 = y1*z1 = z3 */
+    
+    uECC_vli_modAdd(Y1, X1, X1, curve->p, num_words_secp256k1); /* t2 = 2*x1^2 */
+    uECC_vli_modAdd(Y1, Y1, X1, curve->p, num_words_secp256k1); /* t2 = 3*x1^2 */
+    if (uECC_vli_testBit(Y1, 0)) {
+        uECC_word_t carry = uECC_vli_add(Y1, Y1, curve->p, num_words_secp256k1);
+        uECC_vli_rshift1(Y1, num_words_secp256k1);
+        Y1[num_words_secp256k1 - 1] |= carry << (uECC_WORD_BITS - 1);
+    } else {
+        uECC_vli_rshift1(Y1, num_words_secp256k1);
+    }
+    /* t2 = 3/2*(x1^2) = B */
+    
+    uECC_vli_modSquare_fast(X1, Y1, curve);                     /* t1 = B^2 */
+    uECC_vli_modSub(X1, X1, t4, curve->p, num_words_secp256k1); /* t1 = B^2 - A */
+    uECC_vli_modSub(X1, X1, t4, curve->p, num_words_secp256k1); /* t1 = B^2 - 2A = x3 */
+    
+    uECC_vli_modSub(t4, t4, X1, curve->p, num_words_secp256k1); /* t4 = A - x3 */
+    uECC_vli_modMult_fast(Y1, Y1, t4, curve);                   /* t2 = B * (A - x3) */
+    uECC_vli_modSub(Y1, Y1, t5, curve->p, num_words_secp256k1); /* t2 = B * (A - x3) - y1^4 = y3 */
+}
+
+/* Computes result = x^3 + b. result must not overlap x. */
+static void x_side_secp256k1(uECC_word_t *result, const uECC_word_t *x, uECC_Curve curve) {
+    uECC_vli_modSquare_fast(result, x, curve);                                /* r = x^2 */
+    uECC_vli_modMult_fast(result, result, x, curve);                          /* r = x^3 */
+    uECC_vli_modAdd(result, result, curve->b, curve->p, num_words_secp256k1); /* r = x^3 + b */
+}
+
+#if (uECC_OPTIMIZATION_LEVEL > 0 && !asm_mmod_fast_secp256k1)
+static void omega_mult_secp256k1(uECC_word_t *result, const uECC_word_t *right);
+static void vli_mmod_fast_secp256k1(uECC_word_t *result, uECC_word_t *product) {
+    uECC_word_t tmp[2 * num_words_secp256k1];
+    uECC_word_t carry;
+    
+    uECC_vli_clear(tmp, num_words_secp256k1);
+    uECC_vli_clear(tmp + num_words_secp256k1, num_words_secp256k1);
+    
+    omega_mult_secp256k1(tmp, product + num_words_secp256k1); /* (Rq, q) = q * c */
+    
+    carry = uECC_vli_add(result, product, tmp, num_words_secp256k1); /* (C, r) = r + q       */
+    uECC_vli_clear(product, num_words_secp256k1);
+    omega_mult_secp256k1(product, tmp + num_words_secp256k1); /* Rq*c */
+    carry += uECC_vli_add(result, result, product, num_words_secp256k1); /* (C1, r) = r + Rq*c */
+    
+    while (carry > 0) {
+        --carry;
+        uECC_vli_sub(result, result, curve_secp256k1.p, num_words_secp256k1);
+    }
+    if (uECC_vli_cmp_unsafe(result, curve_secp256k1.p, num_words_secp256k1) > 0) {
+        uECC_vli_sub(result, result, curve_secp256k1.p, num_words_secp256k1);
+    }
+}
+
+#if uECC_WORD_SIZE == 1
+static void omega_mult_secp256k1(uint8_t * result, const uint8_t * right) {
+    /* Multiply by (2^32 + 2^9 + 2^8 + 2^7 + 2^6 + 2^4 + 1). */
+    uECC_word_t r0 = 0;
+    uECC_word_t r1 = 0;
+    uECC_word_t r2 = 0;
+    wordcount_t k;
+    
+    /* Multiply by (2^9 + 2^8 + 2^7 + 2^6 + 2^4 + 1). */
+    muladd(0xD1, right[0], &r0, &r1, &r2);
+    result[0] = r0;
+    r0 = r1;
+    r1 = r2;
+    /* r2 is still 0 */
+    
+    for (k = 1; k < num_words_secp256k1; ++k) {
+        muladd(0x03, right[k - 1], &r0, &r1, &r2);
+        muladd(0xD1, right[k], &r0, &r1, &r2);
+        result[k] = r0;
+        r0 = r1;
+        r1 = r2;
+        r2 = 0;
+    }
+    muladd(0x03, right[num_words_secp256k1 - 1], &r0, &r1, &r2);
+    result[num_words_secp256k1] = r0;
+    result[num_words_secp256k1 + 1] = r1;
+    /* add the 2^32 multiple */
+    result[4 + num_words_secp256k1] =
+        uECC_vli_add(result + 4, result + 4, right, num_words_secp256k1); 
+}
+#elif uECC_WORD_SIZE == 4
+static void omega_mult_secp256k1(uint32_t * result, const uint32_t * right) {
+    /* Multiply by (2^9 + 2^8 + 2^7 + 2^6 + 2^4 + 1). */
+    uint32_t carry = 0;
+    wordcount_t k;
+    
+    for (k = 0; k < num_words_secp256k1; ++k) {
+        uint64_t p = (uint64_t)0x3D1 * right[k] + carry;
+        result[k] = (uint32_t) p;
+        carry = p >> 32;
+    }
+    result[num_words_secp256k1] = carry;
+    /* add the 2^32 multiple */
+    result[1 + num_words_secp256k1] =
+        uECC_vli_add(result + 1, result + 1, right, num_words_secp256k1); 
+}
+#else
+static void omega_mult_secp256k1(uint64_t * result, const uint64_t * right) {
+    uECC_word_t r0 = 0;
+    uECC_word_t r1 = 0;
+    uECC_word_t r2 = 0;
+    wordcount_t k;
+    
+    /* Multiply by (2^32 + 2^9 + 2^8 + 2^7 + 2^6 + 2^4 + 1). */
+    for (k = 0; k < num_words_secp256k1; ++k) {
+        muladd(0x1000003D1ull, right[k], &r0, &r1, &r2);
+        result[k] = r0;
+        r0 = r1;
+        r1 = r2;
+        r2 = 0;
+    }
+    result[num_words_secp256k1] = r0;
+}
+#endif /* uECC_WORD_SIZE */
+#endif /* (uECC_OPTIMIZATION_LEVEL > 0 &&  && !asm_mmod_fast_secp256k1) */
+
+#endif /* uECC_SUPPORTS_secp256k1 */
+
+#endif /* _UECC_CURVE_SPECIFIC_H_ */
diff --git a/lib/micro-ecc/platform-specific.inc b/lib/micro-ecc/platform-specific.inc
new file mode 100644
index 00000000..7e0373f5
--- /dev/null
+++ b/lib/micro-ecc/platform-specific.inc
@@ -0,0 +1,94 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_PLATFORM_SPECIFIC_H_
+#define _UECC_PLATFORM_SPECIFIC_H_
+
+#include "types.h"
+
+#if (defined(_WIN32) || defined(_WIN64))
+/* Windows */
+
+// use pragma syntax to prevent tweaking the linker script for getting CryptXYZ function
+#pragma comment(lib, "crypt32.lib")
+#pragma comment(lib, "advapi32.lib")
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <wincrypt.h>
+
+static int default_RNG(uint8_t *dest, unsigned size) {
+    HCRYPTPROV prov;
+    if (!CryptAcquireContext(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) {
+        return 0;
+    }
+
+    CryptGenRandom(prov, size, (BYTE *)dest);
+    CryptReleaseContext(prov, 0);
+    return 1;
+}
+#define default_RNG_defined 1
+
+#elif defined(unix) || defined(__linux__) || defined(__unix__) || defined(__unix) || \
+    (defined(__APPLE__) && defined(__MACH__)) || defined(uECC_POSIX)
+
+/* Some POSIX-like system with /dev/urandom or /dev/random. */
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#ifndef O_CLOEXEC
+    #define O_CLOEXEC 0
+#endif
+
+static int default_RNG(uint8_t *dest, unsigned size) {
+    int fd = open("/dev/urandom", O_RDONLY | O_CLOEXEC);
+    if (fd == -1) {
+        fd = open("/dev/random", O_RDONLY | O_CLOEXEC);
+        if (fd == -1) {
+            return 0;
+        }
+    }
+    
+    char *ptr = (char *)dest;
+    size_t left = size;
+    while (left > 0) {
+        ssize_t bytes_read = read(fd, ptr, left);
+        if (bytes_read <= 0) { // read failed
+            close(fd);
+            return 0;
+        }
+        left -= bytes_read;
+        ptr += bytes_read;
+    }
+    
+    close(fd);
+    return 1;
+}
+#define default_RNG_defined 1
+
+#elif defined(RIOT_VERSION)
+
+#include <random.h>
+
+static int default_RNG(uint8_t *dest, unsigned size) {
+    random_bytes(dest, size);
+    return 1;
+}
+#define default_RNG_defined 1
+
+#elif defined(NRF52_SERIES)
+
+#include "app_error.h"
+#include "nrf_crypto_rng.h"
+
+static int default_RNG(uint8_t *dest, unsigned size) 
+{
+    // make sure to call nrf_crypto_init and nrf_crypto_rng_init first
+    ret_code_t ret_code = nrf_crypto_rng_vector_generate(dest, size);
+    return (ret_code == NRF_SUCCESS) ? 1 : 0;
+}
+#define default_RNG_defined 1
+
+#endif /* platform */
+
+#endif /* _UECC_PLATFORM_SPECIFIC_H_ */
diff --git a/lib/micro-ecc/types.h b/lib/micro-ecc/types.h
new file mode 100644
index 00000000..9ee81438
--- /dev/null
+++ b/lib/micro-ecc/types.h
@@ -0,0 +1,108 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_TYPES_H_
+#define _UECC_TYPES_H_
+
+#ifndef uECC_PLATFORM
+    #if __AVR__
+        #define uECC_PLATFORM uECC_avr
+    #elif defined(__thumb2__) || defined(_M_ARMT) /* I think MSVC only supports Thumb-2 targets */
+        #define uECC_PLATFORM uECC_arm_thumb2
+    #elif defined(__thumb__)
+        #define uECC_PLATFORM uECC_arm_thumb
+    #elif defined(__arm__) || defined(_M_ARM)
+        #define uECC_PLATFORM uECC_arm
+    #elif defined(__aarch64__)
+        #define uECC_PLATFORM uECC_arm64
+    #elif defined(__i386__) || defined(_M_IX86) || defined(_X86_) || defined(__I86__)
+        #define uECC_PLATFORM uECC_x86
+    #elif defined(__amd64__) || defined(_M_X64)
+        #define uECC_PLATFORM uECC_x86_64
+    #else
+        #define uECC_PLATFORM uECC_arch_other
+    #endif
+#endif
+
+#ifndef uECC_ARM_USE_UMAAL
+    #if (uECC_PLATFORM == uECC_arm) && (__ARM_ARCH >= 6)
+        #define uECC_ARM_USE_UMAAL 1
+    #elif (uECC_PLATFORM == uECC_arm_thumb2) && (__ARM_ARCH >= 6) && !__ARM_ARCH_7M__
+        #define uECC_ARM_USE_UMAAL 1
+    #else
+        #define uECC_ARM_USE_UMAAL 0
+    #endif
+#endif
+
+#ifndef uECC_WORD_SIZE
+    #if uECC_PLATFORM == uECC_avr
+        #define uECC_WORD_SIZE 1
+    #elif (uECC_PLATFORM == uECC_x86_64 || uECC_PLATFORM == uECC_arm64)
+        #define uECC_WORD_SIZE 8
+    #else
+        #define uECC_WORD_SIZE 4
+    #endif
+#endif
+
+#if (uECC_WORD_SIZE != 1) && (uECC_WORD_SIZE != 4) && (uECC_WORD_SIZE != 8)
+    #error "Unsupported value for uECC_WORD_SIZE"
+#endif
+
+#if ((uECC_PLATFORM == uECC_avr) && (uECC_WORD_SIZE != 1))
+    #pragma message ("uECC_WORD_SIZE must be 1 for AVR")
+    #undef uECC_WORD_SIZE
+    #define uECC_WORD_SIZE 1
+#endif
+
+#if ((uECC_PLATFORM == uECC_arm || uECC_PLATFORM == uECC_arm_thumb || \
+        uECC_PLATFORM ==  uECC_arm_thumb2) && \
+     (uECC_WORD_SIZE != 4))
+    #pragma message ("uECC_WORD_SIZE must be 4 for ARM")
+    #undef uECC_WORD_SIZE
+    #define uECC_WORD_SIZE 4
+#endif
+
+#if defined(__SIZEOF_INT128__) || ((__clang_major__ * 100 + __clang_minor__) >= 302)
+    #define SUPPORTS_INT128 1
+#else
+    #define SUPPORTS_INT128 0
+#endif
+
+typedef int8_t wordcount_t;
+typedef int16_t bitcount_t;
+typedef int8_t cmpresult_t;
+
+#if (uECC_WORD_SIZE == 1)
+
+typedef uint8_t uECC_word_t;
+typedef uint16_t uECC_dword_t;
+
+#define HIGH_BIT_SET 0x80
+#define uECC_WORD_BITS 8
+#define uECC_WORD_BITS_SHIFT 3
+#define uECC_WORD_BITS_MASK 0x07
+
+#elif (uECC_WORD_SIZE == 4)
+
+typedef uint32_t uECC_word_t;
+typedef uint64_t uECC_dword_t;
+
+#define HIGH_BIT_SET 0x80000000
+#define uECC_WORD_BITS 32
+#define uECC_WORD_BITS_SHIFT 5
+#define uECC_WORD_BITS_MASK 0x01F
+
+#elif (uECC_WORD_SIZE == 8)
+
+typedef uint64_t uECC_word_t;
+#if SUPPORTS_INT128
+typedef unsigned __int128 uECC_dword_t;
+#endif
+
+#define HIGH_BIT_SET 0x8000000000000000ull
+#define uECC_WORD_BITS 64
+#define uECC_WORD_BITS_SHIFT 6
+#define uECC_WORD_BITS_MASK 0x03F
+
+#endif /* uECC_WORD_SIZE */
+
+#endif /* _UECC_TYPES_H_ */
diff --git a/lib/micro-ecc/uECC.c b/lib/micro-ecc/uECC.c
new file mode 100644
index 00000000..a3d502cf
--- /dev/null
+++ b/lib/micro-ecc/uECC.c
@@ -0,0 +1,1669 @@
+/* Copyright 2014, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#include "uECC.h"
+#include "uECC_vli.h"
+
+#ifndef uECC_RNG_MAX_TRIES
+    #define uECC_RNG_MAX_TRIES 64
+#endif
+
+#if uECC_ENABLE_VLI_API
+    #define uECC_VLI_API
+#else
+    #define uECC_VLI_API static
+#endif
+
+#if (uECC_PLATFORM == uECC_avr) || \
+    (uECC_PLATFORM == uECC_arm) || \
+    (uECC_PLATFORM == uECC_arm_thumb) || \
+    (uECC_PLATFORM == uECC_arm_thumb2)
+    #define CONCATX(a, ...) a ## __VA_ARGS__
+    #define CONCAT(a, ...) CONCATX(a, __VA_ARGS__)
+
+    #define STRX(a) #a
+    #define STR(a) STRX(a)
+
+    #define EVAL(...)  EVAL1(EVAL1(EVAL1(EVAL1(__VA_ARGS__))))
+    #define EVAL1(...) EVAL2(EVAL2(EVAL2(EVAL2(__VA_ARGS__))))
+    #define EVAL2(...) EVAL3(EVAL3(EVAL3(EVAL3(__VA_ARGS__))))
+    #define EVAL3(...) EVAL4(EVAL4(EVAL4(EVAL4(__VA_ARGS__))))
+    #define EVAL4(...) __VA_ARGS__
+
+    #define DEC_1  0
+    #define DEC_2  1
+    #define DEC_3  2
+    #define DEC_4  3
+    #define DEC_5  4
+    #define DEC_6  5
+    #define DEC_7  6
+    #define DEC_8  7
+    #define DEC_9  8
+    #define DEC_10 9
+    #define DEC_11 10
+    #define DEC_12 11
+    #define DEC_13 12
+    #define DEC_14 13
+    #define DEC_15 14
+    #define DEC_16 15
+    #define DEC_17 16
+    #define DEC_18 17
+    #define DEC_19 18
+    #define DEC_20 19
+    #define DEC_21 20
+    #define DEC_22 21
+    #define DEC_23 22
+    #define DEC_24 23
+    #define DEC_25 24
+    #define DEC_26 25
+    #define DEC_27 26
+    #define DEC_28 27
+    #define DEC_29 28
+    #define DEC_30 29
+    #define DEC_31 30
+    #define DEC_32 31
+
+    #define DEC(N) CONCAT(DEC_, N)
+
+    #define SECOND_ARG(_, val, ...) val
+    #define SOME_CHECK_0 ~, 0
+    #define GET_SECOND_ARG(...) SECOND_ARG(__VA_ARGS__, SOME,)
+    #define SOME_OR_0(N) GET_SECOND_ARG(CONCAT(SOME_CHECK_, N))
+
+    #define EMPTY(...)
+    #define DEFER(...) __VA_ARGS__ EMPTY()
+
+    #define REPEAT_NAME_0() REPEAT_0
+    #define REPEAT_NAME_SOME() REPEAT_SOME
+    #define REPEAT_0(...)
+    #define REPEAT_SOME(N, stuff) DEFER(CONCAT(REPEAT_NAME_, SOME_OR_0(DEC(N))))()(DEC(N), stuff) stuff
+    #define REPEAT(N, stuff) EVAL(REPEAT_SOME(N, stuff))
+
+    #define REPEATM_NAME_0() REPEATM_0
+    #define REPEATM_NAME_SOME() REPEATM_SOME
+    #define REPEATM_0(...)
+    #define REPEATM_SOME(N, macro) macro(N) \
+        DEFER(CONCAT(REPEATM_NAME_, SOME_OR_0(DEC(N))))()(DEC(N), macro)
+    #define REPEATM(N, macro) EVAL(REPEATM_SOME(N, macro))
+#endif
+
+#include "platform-specific.inc"
+
+#if (uECC_WORD_SIZE == 1)
+    #if uECC_SUPPORTS_secp160r1
+        #define uECC_MAX_WORDS 21 /* Due to the size of curve_n. */
+    #endif
+    #if uECC_SUPPORTS_secp192r1
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 24
+    #endif
+    #if uECC_SUPPORTS_secp224r1
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 28
+    #endif
+    #if (uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1)
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 32
+    #endif
+#elif (uECC_WORD_SIZE == 4)
+    #if uECC_SUPPORTS_secp160r1
+        #define uECC_MAX_WORDS 6 /* Due to the size of curve_n. */
+    #endif
+    #if uECC_SUPPORTS_secp192r1
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 6
+    #endif
+    #if uECC_SUPPORTS_secp224r1
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 7
+    #endif
+    #if (uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1)
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 8
+    #endif
+#elif (uECC_WORD_SIZE == 8)
+    #if uECC_SUPPORTS_secp160r1
+        #define uECC_MAX_WORDS 3
+    #endif
+    #if uECC_SUPPORTS_secp192r1
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 3
+    #endif
+    #if uECC_SUPPORTS_secp224r1
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 4
+    #endif
+    #if (uECC_SUPPORTS_secp256r1 || uECC_SUPPORTS_secp256k1)
+        #undef uECC_MAX_WORDS
+        #define uECC_MAX_WORDS 4
+    #endif
+#endif /* uECC_WORD_SIZE */
+
+#define BITS_TO_WORDS(num_bits) ((num_bits + ((uECC_WORD_SIZE * 8) - 1)) / (uECC_WORD_SIZE * 8))
+#define BITS_TO_BYTES(num_bits) ((num_bits + 7) / 8)
+
+struct uECC_Curve_t {
+    wordcount_t num_words;
+    wordcount_t num_bytes;
+    bitcount_t num_n_bits;
+    uECC_word_t p[uECC_MAX_WORDS];
+    uECC_word_t n[uECC_MAX_WORDS];
+    uECC_word_t G[uECC_MAX_WORDS * 2];
+    uECC_word_t b[uECC_MAX_WORDS];
+    void (*double_jacobian)(uECC_word_t * X1,
+                            uECC_word_t * Y1,
+                            uECC_word_t * Z1,
+                            uECC_Curve curve);
+#if uECC_SUPPORT_COMPRESSED_POINT
+    void (*mod_sqrt)(uECC_word_t *a, uECC_Curve curve);
+#endif
+    void (*x_side)(uECC_word_t *result, const uECC_word_t *x, uECC_Curve curve);
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    void (*mmod_fast)(uECC_word_t *result, uECC_word_t *product);
+#endif
+};
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+static void bcopy(uint8_t *dst,
+                  const uint8_t *src,
+                  unsigned num_bytes) {
+    while (0 != num_bytes) {
+        num_bytes--;
+        dst[num_bytes] = src[num_bytes];
+    }
+}
+#endif
+
+static cmpresult_t uECC_vli_cmp_unsafe(const uECC_word_t *left,
+                                       const uECC_word_t *right,
+                                       wordcount_t num_words);
+
+#if (uECC_PLATFORM == uECC_arm || uECC_PLATFORM == uECC_arm_thumb || \
+        uECC_PLATFORM == uECC_arm_thumb2)
+    #include "asm_arm.inc"
+#endif
+
+#if (uECC_PLATFORM == uECC_avr)
+    #include "asm_avr.inc"
+#endif
+
+#if default_RNG_defined
+static uECC_RNG_Function g_rng_function = &default_RNG;
+#else
+static uECC_RNG_Function g_rng_function = 0;
+#endif
+
+void uECC_set_rng(uECC_RNG_Function rng_function) {
+    g_rng_function = rng_function;
+}
+
+uECC_RNG_Function uECC_get_rng(void) {
+    return g_rng_function;
+}
+
+int uECC_curve_private_key_size(uECC_Curve curve) {
+    return BITS_TO_BYTES(curve->num_n_bits);
+}
+
+int uECC_curve_public_key_size(uECC_Curve curve) {
+    return 2 * curve->num_bytes;
+}
+
+#if !asm_clear
+uECC_VLI_API void uECC_vli_clear(uECC_word_t *vli, wordcount_t num_words) {
+    wordcount_t i;
+    for (i = 0; i < num_words; ++i) {
+        vli[i] = 0;
+    }
+}
+#endif /* !asm_clear */
+
+/* Constant-time comparison to zero - secure way to compare long integers */
+/* Returns 1 if vli == 0, 0 otherwise. */
+uECC_VLI_API uECC_word_t uECC_vli_isZero(const uECC_word_t *vli, wordcount_t num_words) {
+    uECC_word_t bits = 0;
+    wordcount_t i;
+    for (i = 0; i < num_words; ++i) {
+        bits |= vli[i];
+    }
+    return (bits == 0);
+}
+
+/* Returns nonzero if bit 'bit' of vli is set. */
+uECC_VLI_API uECC_word_t uECC_vli_testBit(const uECC_word_t *vli, bitcount_t bit) {
+    return (vli[bit >> uECC_WORD_BITS_SHIFT] & ((uECC_word_t)1 << (bit & uECC_WORD_BITS_MASK)));
+}
+
+/* Counts the number of words in vli. */
+static wordcount_t vli_numDigits(const uECC_word_t *vli, const wordcount_t max_words) {
+    wordcount_t i;
+    /* Search from the end until we find a non-zero digit.
+       We do it in reverse because we expect that most digits will be nonzero. */
+    for (i = max_words - 1; i >= 0 && vli[i] == 0; --i) {
+    }
+
+    return (i + 1);
+}
+
+/* Counts the number of bits required to represent vli. */
+uECC_VLI_API bitcount_t uECC_vli_numBits(const uECC_word_t *vli, const wordcount_t max_words) {
+    uECC_word_t i;
+    uECC_word_t digit;
+
+    wordcount_t num_digits = vli_numDigits(vli, max_words);
+    if (num_digits == 0) {
+        return 0;
+    }
+
+    digit = vli[num_digits - 1];
+    for (i = 0; digit; ++i) {
+        digit >>= 1;
+    }
+
+    return (((bitcount_t)(num_digits - 1) << uECC_WORD_BITS_SHIFT) + i);
+}
+
+/* Sets dest = src. */
+#if !asm_set
+uECC_VLI_API void uECC_vli_set(uECC_word_t *dest, const uECC_word_t *src, wordcount_t num_words) {
+    wordcount_t i;
+    for (i = 0; i < num_words; ++i) {
+        dest[i] = src[i];
+    }
+}
+#endif /* !asm_set */
+
+/* Returns sign of left - right. */
+static cmpresult_t uECC_vli_cmp_unsafe(const uECC_word_t *left,
+                                       const uECC_word_t *right,
+                                       wordcount_t num_words) {
+    wordcount_t i;
+    for (i = num_words - 1; i >= 0; --i) {
+        if (left[i] > right[i]) {
+            return 1;
+        } else if (left[i] < right[i]) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/* Constant-time comparison function - secure way to compare long integers */
+/* Returns one if left == right, zero otherwise. */
+uECC_VLI_API uECC_word_t uECC_vli_equal(const uECC_word_t *left,
+                                        const uECC_word_t *right,
+                                        wordcount_t num_words) {
+    uECC_word_t diff = 0;
+    wordcount_t i;
+    for (i = num_words - 1; i >= 0; --i) {
+        diff |= (left[i] ^ right[i]);
+    }
+    return (diff == 0);
+}
+
+uECC_VLI_API uECC_word_t uECC_vli_sub(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words);
+
+/* Returns sign of left - right, in constant time. */
+uECC_VLI_API cmpresult_t uECC_vli_cmp(const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+    uECC_word_t tmp[uECC_MAX_WORDS];
+    uECC_word_t neg = !!uECC_vli_sub(tmp, left, right, num_words);
+    uECC_word_t equal = uECC_vli_isZero(tmp, num_words);
+    return (!equal - 2 * neg);
+}
+
+/* Computes vli = vli >> 1. */
+#if !asm_rshift1
+uECC_VLI_API void uECC_vli_rshift1(uECC_word_t *vli, wordcount_t num_words) {
+    uECC_word_t *end = vli;
+    uECC_word_t carry = 0;
+
+    vli += num_words;
+    while (vli-- > end) {
+        uECC_word_t temp = *vli;
+        *vli = (temp >> 1) | carry;
+        carry = temp << (uECC_WORD_BITS - 1);
+    }
+}
+#endif /* !asm_rshift1 */
+
+/* Computes result = left + right, returning carry. Can modify in place. */
+#if !asm_add
+uECC_VLI_API uECC_word_t uECC_vli_add(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+    uECC_word_t carry = 0;
+    wordcount_t i;
+    for (i = 0; i < num_words; ++i) {
+        uECC_word_t sum = left[i] + right[i] + carry;
+        if (sum != left[i]) {
+            carry = (sum < left[i]);
+        }
+        result[i] = sum;
+    }
+    return carry;
+}
+#endif /* !asm_add */
+
+/* Computes result = left - right, returning borrow. Can modify in place. */
+#if !asm_sub
+uECC_VLI_API uECC_word_t uECC_vli_sub(uECC_word_t *result,
+                                      const uECC_word_t *left,
+                                      const uECC_word_t *right,
+                                      wordcount_t num_words) {
+    uECC_word_t borrow = 0;
+    wordcount_t i;
+    for (i = 0; i < num_words; ++i) {
+        uECC_word_t diff = left[i] - right[i] - borrow;
+        if (diff != left[i]) {
+            borrow = (diff > left[i]);
+        }
+        result[i] = diff;
+    }
+    return borrow;
+}
+#endif /* !asm_sub */
+
+#if !asm_mult || (uECC_SQUARE_FUNC && !asm_square) || \
+    (uECC_SUPPORTS_secp256k1 && (uECC_OPTIMIZATION_LEVEL > 0) && \
+        ((uECC_WORD_SIZE == 1) || (uECC_WORD_SIZE == 8)))
+static void muladd(uECC_word_t a,
+                   uECC_word_t b,
+                   uECC_word_t *r0,
+                   uECC_word_t *r1,
+                   uECC_word_t *r2) {
+#if uECC_WORD_SIZE == 8 && !SUPPORTS_INT128
+    uint64_t a0 = a & 0xffffffffull;
+    uint64_t a1 = a >> 32;
+    uint64_t b0 = b & 0xffffffffull;
+    uint64_t b1 = b >> 32;
+
+    uint64_t i0 = a0 * b0;
+    uint64_t i1 = a0 * b1;
+    uint64_t i2 = a1 * b0;
+    uint64_t i3 = a1 * b1;
+
+    uint64_t p0, p1;
+
+    i2 += (i0 >> 32);
+    i2 += i1;
+    if (i2 < i1) { /* overflow */
+        i3 += 0x100000000ull;
+    }
+
+    p0 = (i0 & 0xffffffffull) | (i2 << 32);
+    p1 = i3 + (i2 >> 32);
+
+    *r0 += p0;
+    *r1 += (p1 + (*r0 < p0));
+    *r2 += ((*r1 < p1) || (*r1 == p1 && *r0 < p0));
+#else
+    uECC_dword_t p = (uECC_dword_t)a * b;
+    uECC_dword_t r01 = ((uECC_dword_t)(*r1) << uECC_WORD_BITS) | *r0;
+    r01 += p;
+    *r2 += (r01 < p);
+    *r1 = r01 >> uECC_WORD_BITS;
+    *r0 = (uECC_word_t)r01;
+#endif
+}
+#endif /* muladd needed */
+
+#if !asm_mult
+uECC_VLI_API void uECC_vli_mult(uECC_word_t *result,
+                                const uECC_word_t *left,
+                                const uECC_word_t *right,
+                                wordcount_t num_words) {
+    uECC_word_t r0 = 0;
+    uECC_word_t r1 = 0;
+    uECC_word_t r2 = 0;
+    wordcount_t i, k;
+
+    /* Compute each digit of result in sequence, maintaining the carries. */
+    for (k = 0; k < num_words; ++k) {
+        for (i = 0; i <= k; ++i) {
+            muladd(left[i], right[k - i], &r0, &r1, &r2);
+        }
+        result[k] = r0;
+        r0 = r1;
+        r1 = r2;
+        r2 = 0;
+    }
+    for (k = num_words; k < num_words * 2 - 1; ++k) {
+        for (i = (k + 1) - num_words; i < num_words; ++i) {
+            muladd(left[i], right[k - i], &r0, &r1, &r2);
+        }
+        result[k] = r0;
+        r0 = r1;
+        r1 = r2;
+        r2 = 0;
+    }
+    result[num_words * 2 - 1] = r0;
+}
+#endif /* !asm_mult */
+
+#if uECC_SQUARE_FUNC
+
+#if !asm_square
+static void mul2add(uECC_word_t a,
+                    uECC_word_t b,
+                    uECC_word_t *r0,
+                    uECC_word_t *r1,
+                    uECC_word_t *r2) {
+#if uECC_WORD_SIZE == 8 && !SUPPORTS_INT128
+    uint64_t a0 = a & 0xffffffffull;
+    uint64_t a1 = a >> 32;
+    uint64_t b0 = b & 0xffffffffull;
+    uint64_t b1 = b >> 32;
+
+    uint64_t i0 = a0 * b0;
+    uint64_t i1 = a0 * b1;
+    uint64_t i2 = a1 * b0;
+    uint64_t i3 = a1 * b1;
+
+    uint64_t p0, p1;
+
+    i2 += (i0 >> 32);
+    i2 += i1;
+    if (i2 < i1)
+    { /* overflow */
+        i3 += 0x100000000ull;
+    }
+
+    p0 = (i0 & 0xffffffffull) | (i2 << 32);
+    p1 = i3 + (i2 >> 32);
+
+    *r2 += (p1 >> 63);
+    p1 = (p1 << 1) | (p0 >> 63);
+    p0 <<= 1;
+
+    *r0 += p0;
+    *r1 += (p1 + (*r0 < p0));
+    *r2 += ((*r1 < p1) || (*r1 == p1 && *r0 < p0));
+#else
+    uECC_dword_t p = (uECC_dword_t)a * b;
+    uECC_dword_t r01 = ((uECC_dword_t)(*r1) << uECC_WORD_BITS) | *r0;
+    *r2 += (p >> (uECC_WORD_BITS * 2 - 1));
+    p *= 2;
+    r01 += p;
+    *r2 += (r01 < p);
+    *r1 = r01 >> uECC_WORD_BITS;
+    *r0 = (uECC_word_t)r01;
+#endif
+}
+
+uECC_VLI_API void uECC_vli_square(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  wordcount_t num_words) {
+    uECC_word_t r0 = 0;
+    uECC_word_t r1 = 0;
+    uECC_word_t r2 = 0;
+
+    wordcount_t i, k;
+
+    for (k = 0; k < num_words * 2 - 1; ++k) {
+        uECC_word_t min = (k < num_words ? 0 : (k + 1) - num_words);
+        for (i = min; i <= k && i <= k - i; ++i) {
+            if (i < k-i) {
+                mul2add(left[i], left[k - i], &r0, &r1, &r2);
+            } else {
+                muladd(left[i], left[k - i], &r0, &r1, &r2);
+            }
+        }
+        result[k] = r0;
+        r0 = r1;
+        r1 = r2;
+        r2 = 0;
+    }
+
+    result[num_words * 2 - 1] = r0;
+}
+#endif /* !asm_square */
+
+#else /* uECC_SQUARE_FUNC */
+
+#if uECC_ENABLE_VLI_API
+uECC_VLI_API void uECC_vli_square(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  wordcount_t num_words) {
+    uECC_vli_mult(result, left, left, num_words);
+}
+#endif /* uECC_ENABLE_VLI_API */
+
+#endif /* uECC_SQUARE_FUNC */
+
+/* Computes result = (left + right) % mod.
+   Assumes that left < mod and right < mod, and that result does not overlap mod. */
+uECC_VLI_API void uECC_vli_modAdd(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  const uECC_word_t *right,
+                                  const uECC_word_t *mod,
+                                  wordcount_t num_words) {
+    uECC_word_t carry = uECC_vli_add(result, left, right, num_words);
+    if (carry || uECC_vli_cmp_unsafe(mod, result, num_words) != 1) {
+        /* result > mod (result = mod + remainder), so subtract mod to get remainder. */
+        uECC_vli_sub(result, result, mod, num_words);
+    }
+}
+
+/* Computes result = (left - right) % mod.
+   Assumes that left < mod and right < mod, and that result does not overlap mod. */
+uECC_VLI_API void uECC_vli_modSub(uECC_word_t *result,
+                                  const uECC_word_t *left,
+                                  const uECC_word_t *right,
+                                  const uECC_word_t *mod,
+                                  wordcount_t num_words) {
+    uECC_word_t l_borrow = uECC_vli_sub(result, left, right, num_words);
+    if (l_borrow) {
+        /* In this case, result == -diff == (max int) - diff. Since -x % d == d - x,
+           we can get the correct result from result + mod (with overflow). */
+        uECC_vli_add(result, result, mod, num_words);
+    }
+}
+
+/* Computes result = product % mod, where product is 2N words long. */
+/* Currently only designed to work for curve_p or curve_n. */
+uECC_VLI_API void uECC_vli_mmod(uECC_word_t *result,
+                                uECC_word_t *product,
+                                const uECC_word_t *mod,
+                                wordcount_t num_words) {
+    uECC_word_t mod_multiple[2 * uECC_MAX_WORDS];
+    uECC_word_t tmp[2 * uECC_MAX_WORDS];
+    uECC_word_t *v[2] = {tmp, product};
+    uECC_word_t index;
+
+    /* Shift mod so its highest set bit is at the maximum position. */
+    bitcount_t shift = (num_words * 2 * uECC_WORD_BITS) - uECC_vli_numBits(mod, num_words);
+    wordcount_t word_shift = shift / uECC_WORD_BITS;
+    wordcount_t bit_shift = shift % uECC_WORD_BITS;
+    uECC_word_t carry = 0;
+    uECC_vli_clear(mod_multiple, word_shift);
+    if (bit_shift > 0) {
+        for(index = 0; index < (uECC_word_t)num_words; ++index) {
+            mod_multiple[word_shift + index] = (mod[index] << bit_shift) | carry;
+            carry = mod[index] >> (uECC_WORD_BITS - bit_shift);
+        }
+    } else {
+        uECC_vli_set(mod_multiple + word_shift, mod, num_words);
+    }
+
+    for (index = 1; shift >= 0; --shift) {
+        uECC_word_t borrow = 0;
+        wordcount_t i;
+        for (i = 0; i < num_words * 2; ++i) {
+            uECC_word_t diff = v[index][i] - mod_multiple[i] - borrow;
+            if (diff != v[index][i]) {
+                borrow = (diff > v[index][i]);
+            }
+            v[1 - index][i] = diff;
+        }
+        index = !(index ^ borrow); /* Swap the index if there was no borrow */
+        uECC_vli_rshift1(mod_multiple, num_words);
+        mod_multiple[num_words - 1] |= mod_multiple[num_words] << (uECC_WORD_BITS - 1);
+        uECC_vli_rshift1(mod_multiple + num_words, num_words);
+    }
+    uECC_vli_set(result, v[index], num_words);
+}
+
+/* Computes result = (left * right) % mod. */
+uECC_VLI_API void uECC_vli_modMult(uECC_word_t *result,
+                                   const uECC_word_t *left,
+                                   const uECC_word_t *right,
+                                   const uECC_word_t *mod,
+                                   wordcount_t num_words) {
+    uECC_word_t product[2 * uECC_MAX_WORDS];
+    uECC_vli_mult(product, left, right, num_words);
+    uECC_vli_mmod(result, product, mod, num_words);
+}
+
+uECC_VLI_API void uECC_vli_modMult_fast(uECC_word_t *result,
+                                        const uECC_word_t *left,
+                                        const uECC_word_t *right,
+                                        uECC_Curve curve) {
+    uECC_word_t product[2 * uECC_MAX_WORDS];
+    uECC_vli_mult(product, left, right, curve->num_words);
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    curve->mmod_fast(result, product);
+#else
+    uECC_vli_mmod(result, product, curve->p, curve->num_words);
+#endif
+}
+
+#if uECC_SQUARE_FUNC
+
+#if uECC_ENABLE_VLI_API
+/* Computes result = left^2 % mod. */
+uECC_VLI_API void uECC_vli_modSquare(uECC_word_t *result,
+                                     const uECC_word_t *left,
+                                     const uECC_word_t *mod,
+                                     wordcount_t num_words) {
+    uECC_word_t product[2 * uECC_MAX_WORDS];
+    uECC_vli_square(product, left, num_words);
+    uECC_vli_mmod(result, product, mod, num_words);
+}
+#endif /* uECC_ENABLE_VLI_API */
+
+uECC_VLI_API void uECC_vli_modSquare_fast(uECC_word_t *result,
+                                          const uECC_word_t *left,
+                                          uECC_Curve curve) {
+    uECC_word_t product[2 * uECC_MAX_WORDS];
+    uECC_vli_square(product, left, curve->num_words);
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    curve->mmod_fast(result, product);
+#else
+    uECC_vli_mmod(result, product, curve->p, curve->num_words);
+#endif
+}
+
+#else /* uECC_SQUARE_FUNC */
+
+#if uECC_ENABLE_VLI_API
+uECC_VLI_API void uECC_vli_modSquare(uECC_word_t *result,
+                                     const uECC_word_t *left,
+                                     const uECC_word_t *mod,
+                                     wordcount_t num_words) {
+    uECC_vli_modMult(result, left, left, mod, num_words);
+}
+#endif /* uECC_ENABLE_VLI_API */
+
+uECC_VLI_API void uECC_vli_modSquare_fast(uECC_word_t *result,
+                                          const uECC_word_t *left,
+                                          uECC_Curve curve) {
+    uECC_vli_modMult_fast(result, left, left, curve);
+}
+
+#endif /* uECC_SQUARE_FUNC */
+
+#define EVEN(vli) (!(vli[0] & 1))
+static void vli_modInv_update(uECC_word_t *uv,
+                              const uECC_word_t *mod,
+                              wordcount_t num_words) {
+    uECC_word_t carry = 0;
+    if (!EVEN(uv)) {
+        carry = uECC_vli_add(uv, uv, mod, num_words);
+    }
+    uECC_vli_rshift1(uv, num_words);
+    if (carry) {
+        uv[num_words - 1] |= HIGH_BIT_SET;
+    }
+}
+
+/* Computes result = (1 / input) % mod. All VLIs are the same size.
+   See "From Euclid's GCD to Montgomery Multiplication to the Great Divide" */
+uECC_VLI_API void uECC_vli_modInv(uECC_word_t *result,
+                                  const uECC_word_t *input,
+                                  const uECC_word_t *mod,
+                                  wordcount_t num_words) {
+    uECC_word_t a[uECC_MAX_WORDS], b[uECC_MAX_WORDS], u[uECC_MAX_WORDS], v[uECC_MAX_WORDS];
+    cmpresult_t cmpResult;
+
+    if (uECC_vli_isZero(input, num_words)) {
+        uECC_vli_clear(result, num_words);
+        return;
+    }
+
+    uECC_vli_set(a, input, num_words);
+    uECC_vli_set(b, mod, num_words);
+    uECC_vli_clear(u, num_words);
+    u[0] = 1;
+    uECC_vli_clear(v, num_words);
+    while ((cmpResult = uECC_vli_cmp_unsafe(a, b, num_words)) != 0) {
+        if (EVEN(a)) {
+            uECC_vli_rshift1(a, num_words);
+            vli_modInv_update(u, mod, num_words);
+        } else if (EVEN(b)) {
+            uECC_vli_rshift1(b, num_words);
+            vli_modInv_update(v, mod, num_words);
+        } else if (cmpResult > 0) {
+            uECC_vli_sub(a, a, b, num_words);
+            uECC_vli_rshift1(a, num_words);
+            if (uECC_vli_cmp_unsafe(u, v, num_words) < 0) {
+                uECC_vli_add(u, u, mod, num_words);
+            }
+            uECC_vli_sub(u, u, v, num_words);
+            vli_modInv_update(u, mod, num_words);
+        } else {
+            uECC_vli_sub(b, b, a, num_words);
+            uECC_vli_rshift1(b, num_words);
+            if (uECC_vli_cmp_unsafe(v, u, num_words) < 0) {
+                uECC_vli_add(v, v, mod, num_words);
+            }
+            uECC_vli_sub(v, v, u, num_words);
+            vli_modInv_update(v, mod, num_words);
+        }
+    }
+    uECC_vli_set(result, u, num_words);
+}
+
+/* ------ Point operations ------ */
+
+#include "curve-specific.inc"
+
+/* Returns 1 if 'point' is the point at infinity, 0 otherwise. */
+#define EccPoint_isZero(point, curve) uECC_vli_isZero((point), (curve)->num_words * 2)
+
+/* Point multiplication algorithm using Montgomery's ladder with co-Z coordinates.
+From http://eprint.iacr.org/2011/338.pdf
+*/
+
+/* Modify (x1, y1) => (x1 * z^2, y1 * z^3) */
+static void apply_z(uECC_word_t * X1,
+                    uECC_word_t * Y1,
+                    const uECC_word_t * const Z,
+                    uECC_Curve curve) {
+    uECC_word_t t1[uECC_MAX_WORDS];
+
+    uECC_vli_modSquare_fast(t1, Z, curve);    /* z^2 */
+    uECC_vli_modMult_fast(X1, X1, t1, curve); /* x1 * z^2 */
+    uECC_vli_modMult_fast(t1, t1, Z, curve);  /* z^3 */
+    uECC_vli_modMult_fast(Y1, Y1, t1, curve); /* y1 * z^3 */
+}
+
+/* P = (x1, y1) => 2P, (x2, y2) => P' */
+static void XYcZ_initial_double(uECC_word_t * X1,
+                                uECC_word_t * Y1,
+                                uECC_word_t * X2,
+                                uECC_word_t * Y2,
+                                const uECC_word_t * const initial_Z,
+                                uECC_Curve curve) {
+    uECC_word_t z[uECC_MAX_WORDS];
+    wordcount_t num_words = curve->num_words;
+    if (initial_Z) {
+        uECC_vli_set(z, initial_Z, num_words);
+    } else {
+        uECC_vli_clear(z, num_words);
+        z[0] = 1;
+    }
+
+    uECC_vli_set(X2, X1, num_words);
+    uECC_vli_set(Y2, Y1, num_words);
+
+    apply_z(X1, Y1, z, curve);
+    curve->double_jacobian(X1, Y1, z, curve);
+    apply_z(X2, Y2, z, curve);
+}
+
+/* Input P = (x1, y1, Z), Q = (x2, y2, Z)
+   Output P' = (x1', y1', Z3), P + Q = (x3, y3, Z3)
+   or P => P', Q => P + Q
+*/
+static void XYcZ_add(uECC_word_t * X1,
+                     uECC_word_t * Y1,
+                     uECC_word_t * X2,
+                     uECC_word_t * Y2,
+                     uECC_Curve curve) {
+    /* t1 = X1, t2 = Y1, t3 = X2, t4 = Y2 */
+    uECC_word_t t5[uECC_MAX_WORDS];
+    wordcount_t num_words = curve->num_words;
+
+    uECC_vli_modSub(t5, X2, X1, curve->p, num_words); /* t5 = x2 - x1 */
+    uECC_vli_modSquare_fast(t5, t5, curve);                  /* t5 = (x2 - x1)^2 = A */
+    uECC_vli_modMult_fast(X1, X1, t5, curve);                /* t1 = x1*A = B */
+    uECC_vli_modMult_fast(X2, X2, t5, curve);                /* t3 = x2*A = C */
+    uECC_vli_modSub(Y2, Y2, Y1, curve->p, num_words); /* t4 = y2 - y1 */
+    uECC_vli_modSquare_fast(t5, Y2, curve);                  /* t5 = (y2 - y1)^2 = D */
+
+    uECC_vli_modSub(t5, t5, X1, curve->p, num_words); /* t5 = D - B */
+    uECC_vli_modSub(t5, t5, X2, curve->p, num_words); /* t5 = D - B - C = x3 */
+    uECC_vli_modSub(X2, X2, X1, curve->p, num_words); /* t3 = C - B */
+    uECC_vli_modMult_fast(Y1, Y1, X2, curve);                /* t2 = y1*(C - B) */
+    uECC_vli_modSub(X2, X1, t5, curve->p, num_words); /* t3 = B - x3 */
+    uECC_vli_modMult_fast(Y2, Y2, X2, curve);                /* t4 = (y2 - y1)*(B - x3) */
+    uECC_vli_modSub(Y2, Y2, Y1, curve->p, num_words); /* t4 = y3 */
+
+    uECC_vli_set(X2, t5, num_words);
+}
+
+/* Input P = (x1, y1, Z), Q = (x2, y2, Z)
+   Output P + Q = (x3, y3, Z3), P - Q = (x3', y3', Z3)
+   or P => P - Q, Q => P + Q
+*/
+static void XYcZ_addC(uECC_word_t * X1,
+                      uECC_word_t * Y1,
+                      uECC_word_t * X2,
+                      uECC_word_t * Y2,
+                      uECC_Curve curve) {
+    /* t1 = X1, t2 = Y1, t3 = X2, t4 = Y2 */
+    uECC_word_t t5[uECC_MAX_WORDS];
+    uECC_word_t t6[uECC_MAX_WORDS];
+    uECC_word_t t7[uECC_MAX_WORDS];
+    wordcount_t num_words = curve->num_words;
+
+    uECC_vli_modSub(t5, X2, X1, curve->p, num_words); /* t5 = x2 - x1 */
+    uECC_vli_modSquare_fast(t5, t5, curve);                  /* t5 = (x2 - x1)^2 = A */
+    uECC_vli_modMult_fast(X1, X1, t5, curve);                /* t1 = x1*A = B */
+    uECC_vli_modMult_fast(X2, X2, t5, curve);                /* t3 = x2*A = C */
+    uECC_vli_modAdd(t5, Y2, Y1, curve->p, num_words); /* t5 = y2 + y1 */
+    uECC_vli_modSub(Y2, Y2, Y1, curve->p, num_words); /* t4 = y2 - y1 */
+
+    uECC_vli_modSub(t6, X2, X1, curve->p, num_words); /* t6 = C - B */
+    uECC_vli_modMult_fast(Y1, Y1, t6, curve);                /* t2 = y1 * (C - B) = E */
+    uECC_vli_modAdd(t6, X1, X2, curve->p, num_words); /* t6 = B + C */
+    uECC_vli_modSquare_fast(X2, Y2, curve);                  /* t3 = (y2 - y1)^2 = D */
+    uECC_vli_modSub(X2, X2, t6, curve->p, num_words); /* t3 = D - (B + C) = x3 */
+
+    uECC_vli_modSub(t7, X1, X2, curve->p, num_words); /* t7 = B - x3 */
+    uECC_vli_modMult_fast(Y2, Y2, t7, curve);                /* t4 = (y2 - y1)*(B - x3) */
+    uECC_vli_modSub(Y2, Y2, Y1, curve->p, num_words); /* t4 = (y2 - y1)*(B - x3) - E = y3 */
+
+    uECC_vli_modSquare_fast(t7, t5, curve);                  /* t7 = (y2 + y1)^2 = F */
+    uECC_vli_modSub(t7, t7, t6, curve->p, num_words); /* t7 = F - (B + C) = x3' */
+    uECC_vli_modSub(t6, t7, X1, curve->p, num_words); /* t6 = x3' - B */
+    uECC_vli_modMult_fast(t6, t6, t5, curve);                /* t6 = (y2+y1)*(x3' - B) */
+    uECC_vli_modSub(Y1, t6, Y1, curve->p, num_words); /* t2 = (y2+y1)*(x3' - B) - E = y3' */
+
+    uECC_vli_set(X1, t7, num_words);
+}
+
+/* result may overlap point. */
+static void EccPoint_mult(uECC_word_t * result,
+                          const uECC_word_t * point,
+                          const uECC_word_t * scalar,
+                          const uECC_word_t * initial_Z,
+                          bitcount_t num_bits,
+                          uECC_Curve curve) {
+    /* R0 and R1 */
+    uECC_word_t Rx[2][uECC_MAX_WORDS];
+    uECC_word_t Ry[2][uECC_MAX_WORDS];
+    uECC_word_t z[uECC_MAX_WORDS];
+    bitcount_t i;
+    uECC_word_t nb;
+    wordcount_t num_words = curve->num_words;
+
+    uECC_vli_set(Rx[1], point, num_words);
+    uECC_vli_set(Ry[1], point + num_words, num_words);
+
+    XYcZ_initial_double(Rx[1], Ry[1], Rx[0], Ry[0], initial_Z, curve);
+
+    for (i = num_bits - 2; i > 0; --i) {
+        nb = !uECC_vli_testBit(scalar, i);
+        XYcZ_addC(Rx[1 - nb], Ry[1 - nb], Rx[nb], Ry[nb], curve);
+        XYcZ_add(Rx[nb], Ry[nb], Rx[1 - nb], Ry[1 - nb], curve);
+    }
+
+    nb = !uECC_vli_testBit(scalar, 0);
+    XYcZ_addC(Rx[1 - nb], Ry[1 - nb], Rx[nb], Ry[nb], curve);
+
+    /* Find final 1/Z value. */
+    uECC_vli_modSub(z, Rx[1], Rx[0], curve->p, num_words); /* X1 - X0 */
+    uECC_vli_modMult_fast(z, z, Ry[1 - nb], curve);               /* Yb * (X1 - X0) */
+    uECC_vli_modMult_fast(z, z, point, curve);                    /* xP * Yb * (X1 - X0) */
+    uECC_vli_modInv(z, z, curve->p, num_words);            /* 1 / (xP * Yb * (X1 - X0)) */
+    /* yP / (xP * Yb * (X1 - X0)) */
+    uECC_vli_modMult_fast(z, z, point + num_words, curve);
+    uECC_vli_modMult_fast(z, z, Rx[1 - nb], curve); /* Xb * yP / (xP * Yb * (X1 - X0)) */
+    /* End 1/Z calculation */
+
+    XYcZ_add(Rx[nb], Ry[nb], Rx[1 - nb], Ry[1 - nb], curve);
+    apply_z(Rx[0], Ry[0], z, curve);
+
+    uECC_vli_set(result, Rx[0], num_words);
+    uECC_vli_set(result + num_words, Ry[0], num_words);
+}
+
+static uECC_word_t regularize_k(const uECC_word_t * const k,
+                                uECC_word_t *k0,
+                                uECC_word_t *k1,
+                                uECC_Curve curve) {
+    wordcount_t num_n_words = BITS_TO_WORDS(curve->num_n_bits);
+    bitcount_t num_n_bits = curve->num_n_bits;
+    uECC_word_t carry = uECC_vli_add(k0, k, curve->n, num_n_words) ||
+        (num_n_bits < ((bitcount_t)num_n_words * uECC_WORD_SIZE * 8) &&
+         uECC_vli_testBit(k0, num_n_bits));
+    uECC_vli_add(k1, k0, curve->n, num_n_words);
+    return carry;
+}
+
+/* Generates a random integer in the range 0 < random < top.
+   Both random and top have num_words words. */
+uECC_VLI_API int uECC_generate_random_int(uECC_word_t *random,
+                                          const uECC_word_t *top,
+                                          wordcount_t num_words) {
+    uECC_word_t mask = (uECC_word_t)-1;
+    uECC_word_t tries;
+    bitcount_t num_bits = uECC_vli_numBits(top, num_words);
+
+    if (!g_rng_function) {
+        return 0;
+    }
+
+    for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
+        if (!g_rng_function((uint8_t *)random, num_words * uECC_WORD_SIZE)) {
+            return 0;
+        }
+        random[num_words - 1] &= mask >> ((bitcount_t)(num_words * uECC_WORD_SIZE * 8 - num_bits));
+        if (!uECC_vli_isZero(random, num_words) &&
+                uECC_vli_cmp(top, random, num_words) == 1) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static uECC_word_t EccPoint_compute_public_key(uECC_word_t *result,
+                                               uECC_word_t *private_key,
+                                               uECC_Curve curve) {
+    uECC_word_t tmp1[uECC_MAX_WORDS];
+    uECC_word_t tmp2[uECC_MAX_WORDS];
+    uECC_word_t *p2[2] = {tmp1, tmp2};
+    uECC_word_t *initial_Z = 0;
+    uECC_word_t carry;
+
+    /* Regularize the bitcount for the private key so that attackers cannot use a side channel
+       attack to learn the number of leading zeros. */
+    carry = regularize_k(private_key, tmp1, tmp2, curve);
+
+    /* If an RNG function was specified, try to get a random initial Z value to improve
+       protection against side-channel attacks. */
+    if (g_rng_function) {
+        if (!uECC_generate_random_int(p2[carry], curve->p, curve->num_words)) {
+            return 0;
+        }
+        initial_Z = p2[carry];
+    }
+    EccPoint_mult(result, curve->G, p2[!carry], initial_Z, curve->num_n_bits + 1, curve);
+
+    if (EccPoint_isZero(result, curve)) {
+        return 0;
+    }
+    return 1;
+}
+
+#if uECC_WORD_SIZE == 1
+
+uECC_VLI_API void uECC_vli_nativeToBytes(uint8_t *bytes,
+                                         int num_bytes,
+                                         const uint8_t *native) {
+    wordcount_t i;
+    for (i = 0; i < num_bytes; ++i) {
+        bytes[i] = native[(num_bytes - 1) - i];
+    }
+}
+
+uECC_VLI_API void uECC_vli_bytesToNative(uint8_t *native,
+                                         const uint8_t *bytes,
+                                         int num_bytes) {
+    uECC_vli_nativeToBytes(native, num_bytes, bytes);
+}
+
+#else
+
+uECC_VLI_API void uECC_vli_nativeToBytes(uint8_t *bytes,
+                                         int num_bytes,
+                                         const uECC_word_t *native) {
+    int i;
+    for (i = 0; i < num_bytes; ++i) {
+        unsigned b = num_bytes - 1 - i;
+        bytes[i] = native[b / uECC_WORD_SIZE] >> (8 * (b % uECC_WORD_SIZE));
+    }
+}
+
+uECC_VLI_API void uECC_vli_bytesToNative(uECC_word_t *native,
+                                         const uint8_t *bytes,
+                                         int num_bytes) {
+    int i;
+    uECC_vli_clear(native, (num_bytes + (uECC_WORD_SIZE - 1)) / uECC_WORD_SIZE);
+    for (i = 0; i < num_bytes; ++i) {
+        unsigned b = num_bytes - 1 - i;
+        native[b / uECC_WORD_SIZE] |=
+            (uECC_word_t)bytes[i] << (8 * (b % uECC_WORD_SIZE));
+    }
+}
+
+#endif /* uECC_WORD_SIZE */
+
+int uECC_make_key(uint8_t *public_key,
+                  uint8_t *private_key,
+                  uECC_Curve curve) {
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    uECC_word_t *_private = (uECC_word_t *)private_key;
+    uECC_word_t *_public = (uECC_word_t *)public_key;
+#else
+    uECC_word_t _private[uECC_MAX_WORDS];
+    uECC_word_t _public[uECC_MAX_WORDS * 2];
+#endif
+    uECC_word_t tries;
+
+    for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
+        if (!uECC_generate_random_int(_private, curve->n, BITS_TO_WORDS(curve->num_n_bits))) {
+            return 0;
+        }
+
+        if (EccPoint_compute_public_key(_public, _private, curve)) {
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
+            uECC_vli_nativeToBytes(private_key, BITS_TO_BYTES(curve->num_n_bits), _private);
+            uECC_vli_nativeToBytes(public_key, curve->num_bytes, _public);
+            uECC_vli_nativeToBytes(
+                public_key + curve->num_bytes, curve->num_bytes, _public + curve->num_words);
+#endif
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int uECC_shared_secret(const uint8_t *public_key,
+                       const uint8_t *private_key,
+                       uint8_t *secret,
+                       uECC_Curve curve) {
+    uECC_word_t _public[uECC_MAX_WORDS * 2];
+    uECC_word_t _private[uECC_MAX_WORDS];
+
+    uECC_word_t tmp[uECC_MAX_WORDS];
+    uECC_word_t *p2[2] = {_private, tmp};
+    uECC_word_t *initial_Z = 0;
+    uECC_word_t carry;
+    wordcount_t num_words = curve->num_words;
+    wordcount_t num_bytes = curve->num_bytes;
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy((uint8_t *) _private, private_key, num_bytes);
+    bcopy((uint8_t *) _public, public_key, num_bytes*2);
+#else
+    uECC_vli_bytesToNative(_private, private_key, BITS_TO_BYTES(curve->num_n_bits));
+    uECC_vli_bytesToNative(_public, public_key, num_bytes);
+    uECC_vli_bytesToNative(_public + num_words, public_key + num_bytes, num_bytes);
+#endif
+
+    /* Regularize the bitcount for the private key so that attackers cannot use a side channel
+       attack to learn the number of leading zeros. */
+    carry = regularize_k(_private, _private, tmp, curve);
+
+    /* If an RNG function was specified, try to get a random initial Z value to improve
+       protection against side-channel attacks. */
+    if (g_rng_function) {
+        if (!uECC_generate_random_int(p2[carry], curve->p, num_words)) {
+            return 0;
+        }
+        initial_Z = p2[carry];
+    }
+
+    EccPoint_mult(_public, _public, p2[!carry], initial_Z, curve->num_n_bits + 1, curve);
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy((uint8_t *) secret, (uint8_t *) _public, num_bytes);
+#else
+    uECC_vli_nativeToBytes(secret, num_bytes, _public);
+#endif
+    return !EccPoint_isZero(_public, curve);
+}
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+void uECC_compress(const uint8_t *public_key, uint8_t *compressed, uECC_Curve curve) {
+    wordcount_t i;
+    for (i = 0; i < curve->num_bytes; ++i) {
+        compressed[i+1] = public_key[i];
+    }
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    compressed[0] = 2 + (public_key[curve->num_bytes] & 0x01);
+#else
+    compressed[0] = 2 + (public_key[curve->num_bytes * 2 - 1] & 0x01);
+#endif
+}
+
+void uECC_decompress(const uint8_t *compressed, uint8_t *public_key, uECC_Curve curve) {
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    uECC_word_t *point = (uECC_word_t *)public_key;
+#else
+    uECC_word_t point[uECC_MAX_WORDS * 2];
+#endif
+    uECC_word_t *y = point + curve->num_words;
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy(public_key, compressed+1, curve->num_bytes);
+#else
+    uECC_vli_bytesToNative(point, compressed + 1, curve->num_bytes);
+#endif
+    curve->x_side(y, point, curve);
+    curve->mod_sqrt(y, curve);
+
+    if ((y[0] & 0x01) != (compressed[0] & 0x01)) {
+        uECC_vli_sub(y, curve->p, y, curve->num_words);
+    }
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
+    uECC_vli_nativeToBytes(public_key, curve->num_bytes, point);
+    uECC_vli_nativeToBytes(public_key + curve->num_bytes, curve->num_bytes, y);
+#endif
+}
+#endif /* uECC_SUPPORT_COMPRESSED_POINT */
+
+uECC_VLI_API int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve) {
+    uECC_word_t tmp1[uECC_MAX_WORDS];
+    uECC_word_t tmp2[uECC_MAX_WORDS];
+    wordcount_t num_words = curve->num_words;
+
+    /* The point at infinity is invalid. */
+    if (EccPoint_isZero(point, curve)) {
+        return 0;
+    }
+
+    /* x and y must be smaller than p. */
+    if (uECC_vli_cmp_unsafe(curve->p, point, num_words) != 1 ||
+            uECC_vli_cmp_unsafe(curve->p, point + num_words, num_words) != 1) {
+        return 0;
+    }
+
+    uECC_vli_modSquare_fast(tmp1, point + num_words, curve);
+    curve->x_side(tmp2, point, curve); /* tmp2 = x^3 + ax + b */
+
+    /* Make sure that y^2 == x^3 + ax + b */
+    return (int)(uECC_vli_equal(tmp1, tmp2, num_words));
+}
+
+int uECC_valid_public_key(const uint8_t *public_key, uECC_Curve curve) {
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    uECC_word_t *_public = (uECC_word_t *)public_key;
+#else
+    uECC_word_t _public[uECC_MAX_WORDS * 2];
+#endif
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
+    uECC_vli_bytesToNative(_public, public_key, curve->num_bytes);
+    uECC_vli_bytesToNative(
+        _public + curve->num_words, public_key + curve->num_bytes, curve->num_bytes);
+#endif
+    return uECC_valid_point(_public, curve);
+}
+
+int uECC_compute_public_key(const uint8_t *private_key, uint8_t *public_key, uECC_Curve curve) {
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    uECC_word_t *_private = (uECC_word_t *)private_key;
+    uECC_word_t *_public = (uECC_word_t *)public_key;
+#else
+    uECC_word_t _private[uECC_MAX_WORDS];
+    uECC_word_t _public[uECC_MAX_WORDS * 2];
+#endif
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
+    uECC_vli_bytesToNative(_private, private_key, BITS_TO_BYTES(curve->num_n_bits));
+#endif
+
+    /* Make sure the private key is in the range [1, n-1]. */
+    if (uECC_vli_isZero(_private, BITS_TO_WORDS(curve->num_n_bits))) {
+        return 0;
+    }
+
+    if (uECC_vli_cmp(curve->n, _private, BITS_TO_WORDS(curve->num_n_bits)) != 1) {
+        return 0;
+    }
+
+    /* Compute public key. */
+    if (!EccPoint_compute_public_key(_public, _private, curve)) {
+        return 0;
+    }
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
+    uECC_vli_nativeToBytes(public_key, curve->num_bytes, _public);
+    uECC_vli_nativeToBytes(
+        public_key + curve->num_bytes, curve->num_bytes, _public + curve->num_words);
+#endif
+    return 1;
+}
+
+
+/* -------- ECDSA code -------- */
+
+static void bits2int(uECC_word_t *native,
+                     const uint8_t *bits,
+                     unsigned bits_size,
+                     uECC_Curve curve) {
+    unsigned num_n_bytes = BITS_TO_BYTES(curve->num_n_bits);
+    unsigned num_n_words = BITS_TO_WORDS(curve->num_n_bits);
+    int shift;
+    uECC_word_t carry;
+    uECC_word_t *ptr;
+
+    if (bits_size > num_n_bytes) {
+        bits_size = num_n_bytes;
+    }
+
+    uECC_vli_clear(native, num_n_words);
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy((uint8_t *) native, bits, bits_size);
+#else
+    uECC_vli_bytesToNative(native, bits, bits_size);
+#endif
+    if (bits_size * 8 <= (unsigned)curve->num_n_bits) {
+        return;
+    }
+    shift = bits_size * 8 - curve->num_n_bits;
+    carry = 0;
+    ptr = native + num_n_words;
+    while (ptr-- > native) {
+        uECC_word_t temp = *ptr;
+        *ptr = (temp >> shift) | carry;
+        carry = temp << (uECC_WORD_BITS - shift);
+    }
+
+    /* Reduce mod curve_n */
+    if (uECC_vli_cmp_unsafe(curve->n, native, num_n_words) != 1) {
+        uECC_vli_sub(native, native, curve->n, num_n_words);
+    }
+}
+
+static int uECC_sign_with_k_internal(const uint8_t *private_key,
+                            const uint8_t *message_hash,
+                            unsigned hash_size,
+                            uECC_word_t *k,
+                            uint8_t *signature,
+                            uECC_Curve curve) {
+
+    uECC_word_t tmp[uECC_MAX_WORDS];
+    uECC_word_t s[uECC_MAX_WORDS];
+    uECC_word_t *k2[2] = {tmp, s};
+    uECC_word_t *initial_Z = 0;
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    uECC_word_t *p = (uECC_word_t *)signature;
+#else
+    uECC_word_t p[uECC_MAX_WORDS * 2];
+#endif
+    uECC_word_t carry;
+    wordcount_t num_words = curve->num_words;
+    wordcount_t num_n_words = BITS_TO_WORDS(curve->num_n_bits);
+    bitcount_t num_n_bits = curve->num_n_bits;
+
+    /* Make sure 0 < k < curve_n */
+    if (uECC_vli_isZero(k, num_words) || uECC_vli_cmp(curve->n, k, num_n_words) != 1) {
+        return 0;
+    }
+
+    carry = regularize_k(k, tmp, s, curve);
+    /* If an RNG function was specified, try to get a random initial Z value to improve
+       protection against side-channel attacks. */
+    if (g_rng_function) {
+        if (!uECC_generate_random_int(k2[carry], curve->p, num_words)) {
+            return 0;
+        }
+        initial_Z = k2[carry];
+    }
+    EccPoint_mult(p, curve->G, k2[!carry], initial_Z, num_n_bits + 1, curve);
+    if (uECC_vli_isZero(p, num_words)) {
+        return 0;
+    }
+
+    /* If an RNG function was specified, get a random number
+       to prevent side channel analysis of k. */
+    if (!g_rng_function) {
+        uECC_vli_clear(tmp, num_n_words);
+        tmp[0] = 1;
+    } else if (!uECC_generate_random_int(tmp, curve->n, num_n_words)) {
+        return 0;
+    }
+
+    /* Prevent side channel analysis of uECC_vli_modInv() to determine
+       bits of k / the private key by premultiplying by a random number */
+    uECC_vli_modMult(k, k, tmp, curve->n, num_n_words); /* k' = rand * k */
+    uECC_vli_modInv(k, k, curve->n, num_n_words);       /* k = 1 / k' */
+    uECC_vli_modMult(k, k, tmp, curve->n, num_n_words); /* k = 1 / k */
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
+    uECC_vli_nativeToBytes(signature, curve->num_bytes, p); /* store r */
+#endif
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy((uint8_t *) tmp, private_key, BITS_TO_BYTES(curve->num_n_bits));
+#else
+    uECC_vli_bytesToNative(tmp, private_key, BITS_TO_BYTES(curve->num_n_bits)); /* tmp = d */
+#endif
+
+    s[num_n_words - 1] = 0;
+    uECC_vli_set(s, p, num_words);
+    uECC_vli_modMult(s, tmp, s, curve->n, num_n_words); /* s = r*d */
+
+    bits2int(tmp, message_hash, hash_size, curve);
+    uECC_vli_modAdd(s, tmp, s, curve->n, num_n_words); /* s = e + r*d */
+    uECC_vli_modMult(s, s, k, curve->n, num_n_words);  /* s = (e + r*d) / k */
+    if (uECC_vli_numBits(s, num_n_words) > (bitcount_t)curve->num_bytes * 8) {
+        return 0;
+    }
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy((uint8_t *) signature + curve->num_bytes, (uint8_t *) s, curve->num_bytes);
+#else
+    uECC_vli_nativeToBytes(signature + curve->num_bytes, curve->num_bytes, s);
+#endif
+    return 1;
+}
+
+/* For testing - sign with an explicitly specified k value */
+int uECC_sign_with_k(const uint8_t *private_key,
+                            const uint8_t *message_hash,
+                            unsigned hash_size,
+                            const uint8_t *k,
+                            uint8_t *signature,
+                            uECC_Curve curve) {
+    uECC_word_t k2[uECC_MAX_WORDS];
+    bits2int(k2, k, BITS_TO_BYTES(curve->num_n_bits), curve);
+    return uECC_sign_with_k_internal(private_key, message_hash, hash_size, k2, signature, curve);
+}
+
+int uECC_sign(const uint8_t *private_key,
+              const uint8_t *message_hash,
+              unsigned hash_size,
+              uint8_t *signature,
+              uECC_Curve curve) {
+    uECC_word_t k[uECC_MAX_WORDS];
+    uECC_word_t tries;
+
+    for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
+        if (!uECC_generate_random_int(k, curve->n, BITS_TO_WORDS(curve->num_n_bits))) {
+            return 0;
+        }
+
+        if (uECC_sign_with_k_internal(private_key, message_hash, hash_size, k, signature, curve)) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/* Compute an HMAC using K as a key (as in RFC 6979). Note that K is always
+   the same size as the hash result size. */
+static void HMAC_init(const uECC_HashContext *hash_context, const uint8_t *K) {
+    uint8_t *pad = hash_context->tmp + 2 * hash_context->result_size;
+    unsigned i;
+    for (i = 0; i < hash_context->result_size; ++i)
+        pad[i] = K[i] ^ 0x36;
+    for (; i < hash_context->block_size; ++i)
+        pad[i] = 0x36;
+
+    hash_context->init_hash(hash_context);
+    hash_context->update_hash(hash_context, pad, hash_context->block_size);
+}
+
+static void HMAC_update(const uECC_HashContext *hash_context,
+                        const uint8_t *message,
+                        unsigned message_size) {
+    hash_context->update_hash(hash_context, message, message_size);
+}
+
+static void HMAC_finish(const uECC_HashContext *hash_context,
+                        const uint8_t *K,
+                        uint8_t *result) {
+    uint8_t *pad = hash_context->tmp + 2 * hash_context->result_size;
+    unsigned i;
+    for (i = 0; i < hash_context->result_size; ++i)
+        pad[i] = K[i] ^ 0x5c;
+    for (; i < hash_context->block_size; ++i)
+        pad[i] = 0x5c;
+
+    hash_context->finish_hash(hash_context, result);
+
+    hash_context->init_hash(hash_context);
+    hash_context->update_hash(hash_context, pad, hash_context->block_size);
+    hash_context->update_hash(hash_context, result, hash_context->result_size);
+    hash_context->finish_hash(hash_context, result);
+}
+
+/* V = HMAC_K(V) */
+static void update_V(const uECC_HashContext *hash_context, uint8_t *K, uint8_t *V) {
+    HMAC_init(hash_context, K);
+    HMAC_update(hash_context, V, hash_context->result_size);
+    HMAC_finish(hash_context, K, V);
+}
+
+/* Deterministic signing, similar to RFC 6979. Differences are:
+    * We just use H(m) directly rather than bits2octets(H(m))
+      (it is not reduced modulo curve_n).
+    * We generate a value for k (aka T) directly rather than converting endianness.
+
+   Layout of hash_context->tmp: <K> | <V> | (1 byte overlapped 0x00 or 0x01) / <HMAC pad> */
+int uECC_sign_deterministic(const uint8_t *private_key,
+                            const uint8_t *message_hash,
+                            unsigned hash_size,
+                            const uECC_HashContext *hash_context,
+                            uint8_t *signature,
+                            uECC_Curve curve) {
+    uint8_t *K = hash_context->tmp;
+    uint8_t *V = K + hash_context->result_size;
+    wordcount_t num_bytes = curve->num_bytes;
+    wordcount_t num_n_words = BITS_TO_WORDS(curve->num_n_bits);
+    bitcount_t num_n_bits = curve->num_n_bits;
+    uECC_word_t tries;
+    unsigned i;
+    for (i = 0; i < hash_context->result_size; ++i) {
+        V[i] = 0x01;
+        K[i] = 0;
+    }
+
+    /* K = HMAC_K(V || 0x00 || int2octets(x) || h(m)) */
+    HMAC_init(hash_context, K);
+    V[hash_context->result_size] = 0x00;
+    HMAC_update(hash_context, V, hash_context->result_size + 1);
+    HMAC_update(hash_context, private_key, num_bytes);
+    HMAC_update(hash_context, message_hash, hash_size);
+    HMAC_finish(hash_context, K, K);
+
+    update_V(hash_context, K, V);
+
+    /* K = HMAC_K(V || 0x01 || int2octets(x) || h(m)) */
+    HMAC_init(hash_context, K);
+    V[hash_context->result_size] = 0x01;
+    HMAC_update(hash_context, V, hash_context->result_size + 1);
+    HMAC_update(hash_context, private_key, num_bytes);
+    HMAC_update(hash_context, message_hash, hash_size);
+    HMAC_finish(hash_context, K, K);
+
+    update_V(hash_context, K, V);
+
+    for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
+        uECC_word_t T[uECC_MAX_WORDS];
+        uint8_t *T_ptr = (uint8_t *)T;
+        wordcount_t T_bytes = 0;
+        for (;;) {
+            update_V(hash_context, K, V);
+            for (i = 0; i < hash_context->result_size; ++i) {
+                T_ptr[T_bytes++] = V[i];
+                if (T_bytes >= num_n_words * uECC_WORD_SIZE) {
+                    goto filled;
+                }
+            }
+        }
+    filled:
+        if ((bitcount_t)num_n_words * uECC_WORD_SIZE * 8 > num_n_bits) {
+            uECC_word_t mask = (uECC_word_t)-1;
+            T[num_n_words - 1] &=
+                mask >> ((bitcount_t)(num_n_words * uECC_WORD_SIZE * 8 - num_n_bits));
+        }
+
+        if (uECC_sign_with_k_internal(private_key, message_hash, hash_size, T, signature, curve)) {
+            return 1;
+        }
+
+        /* K = HMAC_K(V || 0x00) */
+        HMAC_init(hash_context, K);
+        V[hash_context->result_size] = 0x00;
+        HMAC_update(hash_context, V, hash_context->result_size + 1);
+        HMAC_finish(hash_context, K, K);
+
+        update_V(hash_context, K, V);
+    }
+    return 0;
+}
+
+static bitcount_t smax(bitcount_t a, bitcount_t b) {
+    return (a > b ? a : b);
+}
+
+int uECC_verify(const uint8_t *public_key,
+                const uint8_t *message_hash,
+                unsigned hash_size,
+                const uint8_t *signature,
+                uECC_Curve curve) {
+    uECC_word_t u1[uECC_MAX_WORDS], u2[uECC_MAX_WORDS];
+    uECC_word_t z[uECC_MAX_WORDS];
+    uECC_word_t sum[uECC_MAX_WORDS * 2];
+    uECC_word_t rx[uECC_MAX_WORDS];
+    uECC_word_t ry[uECC_MAX_WORDS];
+    uECC_word_t tx[uECC_MAX_WORDS];
+    uECC_word_t ty[uECC_MAX_WORDS];
+    uECC_word_t tz[uECC_MAX_WORDS];
+    const uECC_word_t *points[4];
+    const uECC_word_t *point;
+    bitcount_t num_bits;
+    bitcount_t i;
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    uECC_word_t *_public = (uECC_word_t *)public_key;
+#else
+    uECC_word_t _public[uECC_MAX_WORDS * 2];
+#endif
+    uECC_word_t r[uECC_MAX_WORDS], s[uECC_MAX_WORDS];
+    wordcount_t num_words = curve->num_words;
+    wordcount_t num_n_words = BITS_TO_WORDS(curve->num_n_bits);
+
+    rx[num_n_words - 1] = 0;
+    r[num_n_words - 1] = 0;
+    s[num_n_words - 1] = 0;
+
+#if uECC_VLI_NATIVE_LITTLE_ENDIAN
+    bcopy((uint8_t *) r, signature, curve->num_bytes);
+    bcopy((uint8_t *) s, signature + curve->num_bytes, curve->num_bytes);
+#else
+    uECC_vli_bytesToNative(_public, public_key, curve->num_bytes);
+    uECC_vli_bytesToNative(
+        _public + num_words, public_key + curve->num_bytes, curve->num_bytes);
+    uECC_vli_bytesToNative(r, signature, curve->num_bytes);
+    uECC_vli_bytesToNative(s, signature + curve->num_bytes, curve->num_bytes);
+#endif
+
+    /* r, s must not be 0. */
+    if (uECC_vli_isZero(r, num_words) || uECC_vli_isZero(s, num_words)) {
+        return 0;
+    }
+
+    /* r, s must be < n. */
+    if (uECC_vli_cmp_unsafe(curve->n, r, num_n_words) != 1 ||
+            uECC_vli_cmp_unsafe(curve->n, s, num_n_words) != 1) {
+        return 0;
+    }
+
+    /* Calculate u1 and u2. */
+    uECC_vli_modInv(z, s, curve->n, num_n_words); /* z = 1/s */
+    u1[num_n_words - 1] = 0;
+    bits2int(u1, message_hash, hash_size, curve);
+    uECC_vli_modMult(u1, u1, z, curve->n, num_n_words); /* u1 = e/s */
+    uECC_vli_modMult(u2, r, z, curve->n, num_n_words); /* u2 = r/s */
+
+    /* Calculate sum = G + Q. */
+    uECC_vli_set(sum, _public, num_words);
+    uECC_vli_set(sum + num_words, _public + num_words, num_words);
+    uECC_vli_set(tx, curve->G, num_words);
+    uECC_vli_set(ty, curve->G + num_words, num_words);
+    uECC_vli_modSub(z, sum, tx, curve->p, num_words); /* z = x2 - x1 */
+    XYcZ_add(tx, ty, sum, sum + num_words, curve);
+    uECC_vli_modInv(z, z, curve->p, num_words); /* z = 1/z */
+    apply_z(sum, sum + num_words, z, curve);
+
+    /* Use Shamir's trick to calculate u1*G + u2*Q */
+    points[0] = 0;
+    points[1] = curve->G;
+    points[2] = _public;
+    points[3] = sum;
+    num_bits = smax(uECC_vli_numBits(u1, num_n_words),
+                    uECC_vli_numBits(u2, num_n_words));
+
+    point = points[(!!uECC_vli_testBit(u1, num_bits - 1)) |
+                   ((!!uECC_vli_testBit(u2, num_bits - 1)) << 1)];
+    uECC_vli_set(rx, point, num_words);
+    uECC_vli_set(ry, point + num_words, num_words);
+    uECC_vli_clear(z, num_words);
+    z[0] = 1;
+
+    for (i = num_bits - 2; i >= 0; --i) {
+        uECC_word_t index;
+        curve->double_jacobian(rx, ry, z, curve);
+
+        index = (!!uECC_vli_testBit(u1, i)) | ((!!uECC_vli_testBit(u2, i)) << 1);
+        point = points[index];
+        if (point) {
+            uECC_vli_set(tx, point, num_words);
+            uECC_vli_set(ty, point + num_words, num_words);
+            apply_z(tx, ty, z, curve);
+            uECC_vli_modSub(tz, rx, tx, curve->p, num_words); /* Z = x2 - x1 */
+            XYcZ_add(tx, ty, rx, ry, curve);
+            uECC_vli_modMult_fast(z, z, tz, curve);
+        }
+    }
+
+    uECC_vli_modInv(z, z, curve->p, num_words); /* Z = 1/Z */
+    apply_z(rx, ry, z, curve);
+
+    /* v = x1 (mod n) */
+    if (uECC_vli_cmp_unsafe(curve->n, rx, num_n_words) != 1) {
+        uECC_vli_sub(rx, rx, curve->n, num_n_words);
+    }
+
+    /* Accept only if v == r. */
+    return (int)(uECC_vli_equal(rx, r, num_words));
+}
+
+#if uECC_ENABLE_VLI_API
+
+unsigned uECC_curve_num_words(uECC_Curve curve) {
+    return curve->num_words;
+}
+
+unsigned uECC_curve_num_bytes(uECC_Curve curve) {
+    return curve->num_bytes;
+}
+
+unsigned uECC_curve_num_bits(uECC_Curve curve) {
+    return curve->num_bytes * 8;
+}
+
+unsigned uECC_curve_num_n_words(uECC_Curve curve) {
+    return BITS_TO_WORDS(curve->num_n_bits);
+}
+
+unsigned uECC_curve_num_n_bytes(uECC_Curve curve) {
+    return BITS_TO_BYTES(curve->num_n_bits);
+}
+
+unsigned uECC_curve_num_n_bits(uECC_Curve curve) {
+    return curve->num_n_bits;
+}
+
+const uECC_word_t *uECC_curve_p(uECC_Curve curve) {
+    return curve->p;
+}
+
+const uECC_word_t *uECC_curve_n(uECC_Curve curve) {
+    return curve->n;
+}
+
+const uECC_word_t *uECC_curve_G(uECC_Curve curve) {
+    return curve->G;
+}
+
+const uECC_word_t *uECC_curve_b(uECC_Curve curve) {
+    return curve->b;
+}
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+void uECC_vli_mod_sqrt(uECC_word_t *a, uECC_Curve curve) {
+    curve->mod_sqrt(a, curve);
+}
+#endif
+
+void uECC_vli_mmod_fast(uECC_word_t *result, uECC_word_t *product, uECC_Curve curve) {
+#if (uECC_OPTIMIZATION_LEVEL > 0)
+    curve->mmod_fast(result, product);
+#else
+    uECC_vli_mmod(result, product, curve->p, curve->num_words);
+#endif
+}
+
+void uECC_point_mult(uECC_word_t *result,
+                     const uECC_word_t *point,
+                     const uECC_word_t *scalar,
+                     uECC_Curve curve) {
+    uECC_word_t tmp1[uECC_MAX_WORDS];
+    uECC_word_t tmp2[uECC_MAX_WORDS];
+    uECC_word_t *p2[2] = {tmp1, tmp2};
+    uECC_word_t carry = regularize_k(scalar, tmp1, tmp2, curve);
+
+    EccPoint_mult(result, point, p2[!carry], 0, curve->num_n_bits + 1, curve);
+}
+
+#endif /* uECC_ENABLE_VLI_API */
diff --git a/lib/micro-ecc/uECC.h b/lib/micro-ecc/uECC.h
new file mode 100644
index 00000000..dcbdbfa8
--- /dev/null
+++ b/lib/micro-ecc/uECC.h
@@ -0,0 +1,367 @@
+/* Copyright 2014, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_H_
+#define _UECC_H_
+
+#include <stdint.h>
+
+/* Platform selection options.
+If uECC_PLATFORM is not defined, the code will try to guess it based on compiler macros.
+Possible values for uECC_PLATFORM are defined below: */
+#define uECC_arch_other 0
+#define uECC_x86        1
+#define uECC_x86_64     2
+#define uECC_arm        3
+#define uECC_arm_thumb  4
+#define uECC_arm_thumb2 5
+#define uECC_arm64      6
+#define uECC_avr        7
+
+/* If desired, you can define uECC_WORD_SIZE as appropriate for your platform (1, 4, or 8 bytes).
+If uECC_WORD_SIZE is not explicitly defined then it will be automatically set based on your
+platform. */
+
+/* Optimization level; trade speed for code size.
+   Larger values produce code that is faster but larger.
+   Currently supported values are 0 - 4; 0 is unusably slow for most applications.
+   Optimization level 4 currently only has an effect ARM platforms where more than one
+   curve is enabled. */
+#ifndef uECC_OPTIMIZATION_LEVEL
+    #define uECC_OPTIMIZATION_LEVEL 2
+#endif
+
+/* uECC_SQUARE_FUNC - If enabled (defined as nonzero), this will cause a specific function to be
+used for (scalar) squaring instead of the generic multiplication function. This can make things
+faster somewhat faster, but increases the code size. */
+#ifndef uECC_SQUARE_FUNC
+    #define uECC_SQUARE_FUNC 0
+#endif
+
+/* uECC_VLI_NATIVE_LITTLE_ENDIAN - If enabled (defined as nonzero), this will switch to native
+little-endian format for *all* arrays passed in and out of the public API. This includes public
+and private keys, shared secrets, signatures and message hashes.
+Using this switch reduces the amount of call stack memory used by uECC, since less intermediate
+translations are required.
+Note that this will *only* work on native little-endian processors and it will treat the uint8_t
+arrays passed into the public API as word arrays, therefore requiring the provided byte arrays
+to be word aligned on architectures that do not support unaligned accesses.
+IMPORTANT: Keys and signatures generated with uECC_VLI_NATIVE_LITTLE_ENDIAN=1 are incompatible
+with keys and signatures generated with uECC_VLI_NATIVE_LITTLE_ENDIAN=0; all parties must use
+the same endianness. */
+#ifndef uECC_VLI_NATIVE_LITTLE_ENDIAN
+    #define uECC_VLI_NATIVE_LITTLE_ENDIAN 0
+#endif
+
+/* Curve support selection. Set to 0 to remove that curve. */
+#ifndef uECC_SUPPORTS_secp160r1
+    #define uECC_SUPPORTS_secp160r1 1
+#endif
+#ifndef uECC_SUPPORTS_secp192r1
+    #define uECC_SUPPORTS_secp192r1 1
+#endif
+#ifndef uECC_SUPPORTS_secp224r1
+    #define uECC_SUPPORTS_secp224r1 1
+#endif
+#ifndef uECC_SUPPORTS_secp256r1
+    #define uECC_SUPPORTS_secp256r1 1
+#endif
+#ifndef uECC_SUPPORTS_secp256k1
+    #define uECC_SUPPORTS_secp256k1 1
+#endif
+
+/* Specifies whether compressed point format is supported.
+   Set to 0 to disable point compression/decompression functions. */
+#ifndef uECC_SUPPORT_COMPRESSED_POINT
+    #define uECC_SUPPORT_COMPRESSED_POINT 1
+#endif
+
+struct uECC_Curve_t;
+typedef const struct uECC_Curve_t * uECC_Curve;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if uECC_SUPPORTS_secp160r1
+uECC_Curve uECC_secp160r1(void);
+#endif
+#if uECC_SUPPORTS_secp192r1
+uECC_Curve uECC_secp192r1(void);
+#endif
+#if uECC_SUPPORTS_secp224r1
+uECC_Curve uECC_secp224r1(void);
+#endif
+#if uECC_SUPPORTS_secp256r1
+uECC_Curve uECC_secp256r1(void);
+#endif
+#if uECC_SUPPORTS_secp256k1
+uECC_Curve uECC_secp256k1(void);
+#endif
+
+/* uECC_RNG_Function type
+The RNG function should fill 'size' random bytes into 'dest'. It should return 1 if
+'dest' was filled with random data, or 0 if the random data could not be generated.
+The filled-in values should be either truly random, or from a cryptographically-secure PRNG.
+
+A correctly functioning RNG function must be set (using uECC_set_rng()) before calling
+uECC_make_key() or uECC_sign().
+
+Setting a correctly functioning RNG function improves the resistance to side-channel attacks
+for uECC_shared_secret() and uECC_sign_deterministic().
+
+A correct RNG function is set by default when building for Windows, Linux, or OS X.
+If you are building on another POSIX-compliant system that supports /dev/random or /dev/urandom,
+you can define uECC_POSIX to use the predefined RNG. For embedded platforms there is no predefined
+RNG function; you must provide your own.
+*/
+typedef int (*uECC_RNG_Function)(uint8_t *dest, unsigned size);
+
+/* uECC_set_rng() function.
+Set the function that will be used to generate random bytes. The RNG function should
+return 1 if the random data was generated, or 0 if the random data could not be generated.
+
+On platforms where there is no predefined RNG function (eg embedded platforms), this must
+be called before uECC_make_key() or uECC_sign() are used.
+
+Inputs:
+    rng_function - The function that will be used to generate random bytes.
+*/
+void uECC_set_rng(uECC_RNG_Function rng_function);
+
+/* uECC_get_rng() function.
+
+Returns the function that will be used to generate random bytes.
+*/
+uECC_RNG_Function uECC_get_rng(void);
+
+/* uECC_curve_private_key_size() function.
+
+Returns the size of a private key for the curve in bytes.
+*/
+int uECC_curve_private_key_size(uECC_Curve curve);
+
+/* uECC_curve_public_key_size() function.
+
+Returns the size of a public key for the curve in bytes.
+*/
+int uECC_curve_public_key_size(uECC_Curve curve);
+
+/* uECC_make_key() function.
+Create a public/private key pair.
+
+Outputs:
+    public_key  - Will be filled in with the public key. Must be at least 2 * the curve size
+                  (in bytes) long. For example, if the curve is secp256r1, public_key must be 64
+                  bytes long.
+    private_key - Will be filled in with the private key. Must be as long as the curve order; this
+                  is typically the same as the curve size, except for secp160r1. For example, if the
+                  curve is secp256r1, private_key must be 32 bytes long.
+
+                  For secp160r1, private_key must be 21 bytes long! Note that the first byte will
+                  almost always be 0 (there is about a 1 in 2^80 chance of it being non-zero).
+
+Returns 1 if the key pair was generated successfully, 0 if an error occurred.
+*/
+int uECC_make_key(uint8_t *public_key, uint8_t *private_key, uECC_Curve curve);
+
+/* uECC_shared_secret() function.
+Compute a shared secret given your secret key and someone else's public key. If the public key
+is not from a trusted source and has not been previously verified, you should verify it first
+using uECC_valid_public_key().
+Note: It is recommended that you hash the result of uECC_shared_secret() before using it for
+symmetric encryption or HMAC.
+
+Inputs:
+    public_key  - The public key of the remote party.
+    private_key - Your private key.
+
+Outputs:
+    secret - Will be filled in with the shared secret value. Must be the same size as the
+             curve size; for example, if the curve is secp256r1, secret must be 32 bytes long.
+
+Returns 1 if the shared secret was generated successfully, 0 if an error occurred.
+*/
+int uECC_shared_secret(const uint8_t *public_key,
+                       const uint8_t *private_key,
+                       uint8_t *secret,
+                       uECC_Curve curve);
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+/* uECC_compress() function.
+Compress a public key.
+
+Inputs:
+    public_key - The public key to compress.
+
+Outputs:
+    compressed - Will be filled in with the compressed public key. Must be at least
+                 (curve size + 1) bytes long; for example, if the curve is secp256r1,
+                 compressed must be 33 bytes long.
+*/
+void uECC_compress(const uint8_t *public_key, uint8_t *compressed, uECC_Curve curve);
+
+/* uECC_decompress() function.
+Decompress a compressed public key.
+
+Inputs:
+    compressed - The compressed public key.
+
+Outputs:
+    public_key - Will be filled in with the decompressed public key.
+*/
+void uECC_decompress(const uint8_t *compressed, uint8_t *public_key, uECC_Curve curve);
+#endif /* uECC_SUPPORT_COMPRESSED_POINT */
+
+/* uECC_valid_public_key() function.
+Check to see if a public key is valid.
+
+Note that you are not required to check for a valid public key before using any other uECC
+functions. However, you may wish to avoid spending CPU time computing a shared secret or
+verifying a signature using an invalid public key.
+
+Inputs:
+    public_key - The public key to check.
+
+Returns 1 if the public key is valid, 0 if it is invalid.
+*/
+int uECC_valid_public_key(const uint8_t *public_key, uECC_Curve curve);
+
+/* uECC_compute_public_key() function.
+Compute the corresponding public key for a private key.
+
+Inputs:
+    private_key - The private key to compute the public key for
+
+Outputs:
+    public_key - Will be filled in with the corresponding public key
+
+Returns 1 if the key was computed successfully, 0 if an error occurred.
+*/
+int uECC_compute_public_key(const uint8_t *private_key, uint8_t *public_key, uECC_Curve curve);
+
+/* uECC_sign() function.
+Generate an ECDSA signature for a given hash value.
+
+Usage: Compute a hash of the data you wish to sign (SHA-2 is recommended) and pass it in to
+this function along with your private key.
+
+Inputs:
+    private_key  - Your private key.
+    message_hash - The hash of the message to sign.
+    hash_size    - The size of message_hash in bytes.
+
+Outputs:
+    signature - Will be filled in with the signature value. Must be at least 2 * curve size long.
+                For example, if the curve is secp256r1, signature must be 64 bytes long.
+
+Returns 1 if the signature generated successfully, 0 if an error occurred.
+*/
+int uECC_sign(const uint8_t *private_key,
+              const uint8_t *message_hash,
+              unsigned hash_size,
+              uint8_t *signature,
+              uECC_Curve curve);
+
+/* uECC_HashContext structure.
+This is used to pass in an arbitrary hash function to uECC_sign_deterministic().
+The structure will be used for multiple hash computations; each time a new hash
+is computed, init_hash() will be called, followed by one or more calls to
+update_hash(), and finally a call to finish_hash() to produce the resulting hash.
+
+The intention is that you will create a structure that includes uECC_HashContext
+followed by any hash-specific data. For example:
+
+typedef struct SHA256_HashContext {
+    uECC_HashContext uECC;
+    SHA256_CTX ctx;
+} SHA256_HashContext;
+
+void init_SHA256(uECC_HashContext *base) {
+    SHA256_HashContext *context = (SHA256_HashContext *)base;
+    SHA256_Init(&context->ctx);
+}
+
+void update_SHA256(uECC_HashContext *base,
+                   const uint8_t *message,
+                   unsigned message_size) {
+    SHA256_HashContext *context = (SHA256_HashContext *)base;
+    SHA256_Update(&context->ctx, message, message_size);
+}
+
+void finish_SHA256(uECC_HashContext *base, uint8_t *hash_result) {
+    SHA256_HashContext *context = (SHA256_HashContext *)base;
+    SHA256_Final(hash_result, &context->ctx);
+}
+
+... when signing ...
+{
+    uint8_t tmp[32 + 32 + 64];
+    SHA256_HashContext ctx = {{&init_SHA256, &update_SHA256, &finish_SHA256, 64, 32, tmp}};
+    uECC_sign_deterministic(key, message_hash, &ctx.uECC, signature);
+}
+*/
+typedef struct uECC_HashContext {
+    void (*init_hash)(const struct uECC_HashContext *context);
+    void (*update_hash)(const struct uECC_HashContext *context,
+                        const uint8_t *message,
+                        unsigned message_size);
+    void (*finish_hash)(const struct uECC_HashContext *context, uint8_t *hash_result);
+    unsigned block_size; /* Hash function block size in bytes, eg 64 for SHA-256. */
+    unsigned result_size; /* Hash function result size in bytes, eg 32 for SHA-256. */
+    uint8_t *tmp; /* Must point to a buffer of at least (2 * result_size + block_size) bytes. */
+} uECC_HashContext;
+
+/* uECC_sign_deterministic() function.
+Generate an ECDSA signature for a given hash value, using a deterministic algorithm
+(see RFC 6979). You do not need to set the RNG using uECC_set_rng() before calling
+this function; however, if the RNG is defined it will improve resistance to side-channel
+attacks.
+
+Usage: Compute a hash of the data you wish to sign (SHA-2 is recommended) and pass it to
+this function along with your private key and a hash context. Note that the message_hash
+does not need to be computed with the same hash function used by hash_context.
+
+Inputs:
+    private_key  - Your private key.
+    message_hash - The hash of the message to sign.
+    hash_size    - The size of message_hash in bytes.
+    hash_context - A hash context to use.
+
+Outputs:
+    signature - Will be filled in with the signature value.
+
+Returns 1 if the signature generated successfully, 0 if an error occurred.
+*/
+int uECC_sign_deterministic(const uint8_t *private_key,
+                            const uint8_t *message_hash,
+                            unsigned hash_size,
+                            const uECC_HashContext *hash_context,
+                            uint8_t *signature,
+                            uECC_Curve curve);
+
+/* uECC_verify() function.
+Verify an ECDSA signature.
+
+Usage: Compute the hash of the signed data using the same hash as the signer and
+pass it to this function along with the signer's public key and the signature values (r and s).
+
+Inputs:
+    public_key   - The signer's public key.
+    message_hash - The hash of the signed data.
+    hash_size    - The size of message_hash in bytes.
+    signature    - The signature value.
+
+Returns 1 if the signature is valid, 0 if it is invalid.
+*/
+int uECC_verify(const uint8_t *public_key,
+                const uint8_t *message_hash,
+                unsigned hash_size,
+                const uint8_t *signature,
+                uECC_Curve curve);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _UECC_H_ */
diff --git a/lib/micro-ecc/uECC_vli.h b/lib/micro-ecc/uECC_vli.h
new file mode 100644
index 00000000..864cc333
--- /dev/null
+++ b/lib/micro-ecc/uECC_vli.h
@@ -0,0 +1,172 @@
+/* Copyright 2015, Kenneth MacKay. Licensed under the BSD 2-clause license. */
+
+#ifndef _UECC_VLI_H_
+#define _UECC_VLI_H_
+
+#include "uECC.h"
+#include "types.h"
+
+/* Functions for raw large-integer manipulation. These are only available
+   if uECC.c is compiled with uECC_ENABLE_VLI_API defined to 1. */
+#ifndef uECC_ENABLE_VLI_API
+    #define uECC_ENABLE_VLI_API 0
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if uECC_ENABLE_VLI_API
+
+void uECC_vli_clear(uECC_word_t *vli, wordcount_t num_words);
+
+/* Constant-time comparison to zero - secure way to compare long integers */
+/* Returns 1 if vli == 0, 0 otherwise. */
+uECC_word_t uECC_vli_isZero(const uECC_word_t *vli, wordcount_t num_words);
+
+/* Returns nonzero if bit 'bit' of vli is set. */
+uECC_word_t uECC_vli_testBit(const uECC_word_t *vli, bitcount_t bit);
+
+/* Counts the number of bits required to represent vli. */
+bitcount_t uECC_vli_numBits(const uECC_word_t *vli, const wordcount_t max_words);
+
+/* Sets dest = src. */
+void uECC_vli_set(uECC_word_t *dest, const uECC_word_t *src, wordcount_t num_words);
+
+/* Constant-time comparison function - secure way to compare long integers */
+/* Returns one if left == right, zero otherwise */
+uECC_word_t uECC_vli_equal(const uECC_word_t *left,
+                           const uECC_word_t *right,
+                           wordcount_t num_words);
+
+/* Constant-time comparison function - secure way to compare long integers */
+/* Returns sign of left - right, in constant time. */
+cmpresult_t uECC_vli_cmp(const uECC_word_t *left, const uECC_word_t *right, wordcount_t num_words);
+
+/* Computes vli = vli >> 1. */
+void uECC_vli_rshift1(uECC_word_t *vli, wordcount_t num_words);
+
+/* Computes result = left + right, returning carry. Can modify in place. */
+uECC_word_t uECC_vli_add(uECC_word_t *result,
+                         const uECC_word_t *left,
+                         const uECC_word_t *right,
+                         wordcount_t num_words);
+
+/* Computes result = left - right, returning borrow. Can modify in place. */
+uECC_word_t uECC_vli_sub(uECC_word_t *result,
+                         const uECC_word_t *left,
+                         const uECC_word_t *right,
+                         wordcount_t num_words);
+
+/* Computes result = left * right. Result must be 2 * num_words long. */
+void uECC_vli_mult(uECC_word_t *result,
+                   const uECC_word_t *left,
+                   const uECC_word_t *right,
+                   wordcount_t num_words);
+
+/* Computes result = left^2. Result must be 2 * num_words long. */
+void uECC_vli_square(uECC_word_t *result, const uECC_word_t *left, wordcount_t num_words);
+
+/* Computes result = (left + right) % mod.
+   Assumes that left < mod and right < mod, and that result does not overlap mod. */
+void uECC_vli_modAdd(uECC_word_t *result,
+                     const uECC_word_t *left,
+                     const uECC_word_t *right,
+                     const uECC_word_t *mod,
+                     wordcount_t num_words);
+
+/* Computes result = (left - right) % mod.
+   Assumes that left < mod and right < mod, and that result does not overlap mod. */
+void uECC_vli_modSub(uECC_word_t *result,
+                     const uECC_word_t *left,
+                     const uECC_word_t *right,
+                     const uECC_word_t *mod,
+                     wordcount_t num_words);
+
+/* Computes result = product % mod, where product is 2N words long.
+   Currently only designed to work for mod == curve->p or curve_n. */
+void uECC_vli_mmod(uECC_word_t *result,
+                   uECC_word_t *product,
+                   const uECC_word_t *mod,
+                   wordcount_t num_words);
+
+/* Calculates result = product (mod curve->p), where product is up to
+   2 * curve->num_words long. */
+void uECC_vli_mmod_fast(uECC_word_t *result, uECC_word_t *product, uECC_Curve curve);
+
+/* Computes result = (left * right) % mod.
+   Currently only designed to work for mod == curve->p or curve_n. */
+void uECC_vli_modMult(uECC_word_t *result,
+                      const uECC_word_t *left,
+                      const uECC_word_t *right,
+                      const uECC_word_t *mod,
+                      wordcount_t num_words);
+
+/* Computes result = (left * right) % curve->p. */
+void uECC_vli_modMult_fast(uECC_word_t *result,
+                           const uECC_word_t *left,
+                           const uECC_word_t *right,
+                           uECC_Curve curve);
+
+/* Computes result = left^2 % mod.
+   Currently only designed to work for mod == curve->p or curve_n. */
+void uECC_vli_modSquare(uECC_word_t *result,
+                        const uECC_word_t *left,
+                        const uECC_word_t *mod,
+                        wordcount_t num_words);
+
+/* Computes result = left^2 % curve->p. */
+void uECC_vli_modSquare_fast(uECC_word_t *result, const uECC_word_t *left, uECC_Curve curve);
+
+/* Computes result = (1 / input) % mod.*/
+void uECC_vli_modInv(uECC_word_t *result,
+                     const uECC_word_t *input,
+                     const uECC_word_t *mod,
+                     wordcount_t num_words);
+
+#if uECC_SUPPORT_COMPRESSED_POINT
+/* Calculates a = sqrt(a) (mod curve->p) */
+void uECC_vli_mod_sqrt(uECC_word_t *a, uECC_Curve curve);
+#endif
+
+/* Converts an integer in uECC native format to big-endian bytes. */
+void uECC_vli_nativeToBytes(uint8_t *bytes, int num_bytes, const uECC_word_t *native);
+/* Converts big-endian bytes to an integer in uECC native format. */
+void uECC_vli_bytesToNative(uECC_word_t *native, const uint8_t *bytes, int num_bytes);
+
+unsigned uECC_curve_num_words(uECC_Curve curve);
+unsigned uECC_curve_num_bytes(uECC_Curve curve);
+unsigned uECC_curve_num_bits(uECC_Curve curve);
+unsigned uECC_curve_num_n_words(uECC_Curve curve);
+unsigned uECC_curve_num_n_bytes(uECC_Curve curve);
+unsigned uECC_curve_num_n_bits(uECC_Curve curve);
+
+const uECC_word_t *uECC_curve_p(uECC_Curve curve);
+const uECC_word_t *uECC_curve_n(uECC_Curve curve);
+const uECC_word_t *uECC_curve_G(uECC_Curve curve);
+const uECC_word_t *uECC_curve_b(uECC_Curve curve);
+
+int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve);
+
+/* Multiplies a point by a scalar. Points are represented by the X coordinate followed by
+   the Y coordinate in the same array, both coordinates are curve->num_words long. Note
+   that scalar must be curve->num_n_words long (NOT curve->num_words). */
+void uECC_point_mult(uECC_word_t *result,
+                     const uECC_word_t *point,
+                     const uECC_word_t *scalar,
+                     uECC_Curve curve);
+
+/* Generates a random integer in the range 0 < random < top.
+   Both random and top have num_words words. */
+int uECC_generate_random_int(uECC_word_t *random,
+                             const uECC_word_t *top,
+                             wordcount_t num_words);
+
+#endif /* uECC_ENABLE_VLI_API */
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif /* _UECC_VLI_H_ */
diff --git a/lib/toolbox/hmac_sha256.c b/lib/toolbox/hmac_sha256.c
new file mode 100644
index 00000000..93570216
--- /dev/null
+++ b/lib/toolbox/hmac_sha256.c
@@ -0,0 +1,123 @@
+/*
+ * hmac.c - HMAC
+ *
+ * Copyright (C) 2017 Sergei Glushchenko
+ * Author: Sergei Glushchenko <gl.sergei@gmail.com>
+ *
+ * This file is a part of U2F firmware for STM32
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * As additional permission under GNU GPL version 3 section 7, you may
+ * distribute non-source form of the Program without the copy of the
+ * GNU GPL normally required by section 4, provided you inform the
+ * recipients of GNU GPL by a written offer.
+ *
+ */
+#include <stdint.h>
+
+#include "sha256.h"
+#include "hmac_sha256.h"
+
+static void
+_hmac_sha256_init (const hmac_context *ctx)
+{
+  hmac_sha256_context *context = (hmac_sha256_context *)ctx;
+  sha256_start(&context->sha_ctx);
+}
+
+static void
+_hmac_sha256_update (const hmac_context *ctx, const uint8_t *message,
+                    unsigned message_size)
+{
+  hmac_sha256_context *context = (hmac_sha256_context *)ctx;
+  sha256_update(&context->sha_ctx, message, message_size);
+}
+
+static void
+_hmac_sha256_finish (const hmac_context *ctx, uint8_t *hash_result)
+{
+  hmac_sha256_context *context = (hmac_sha256_context *)ctx;
+  sha256_finish(&context->sha_ctx, hash_result);
+}
+
+/* Compute an HMAC using K as a key (as in RFC 6979). Note that K is always
+   the same size as the hash result size. */
+static void
+hmac_init(const hmac_context *ctx, const uint8_t *K)
+{
+  uint8_t *pad = ctx->tmp + 2 * ctx->result_size;
+  unsigned i;
+  for (i = 0; i < ctx->result_size; ++i)
+    pad[i] = K[i] ^ 0x36;
+  for (; i < ctx->block_size; ++i)
+    pad[i] = 0x36;
+
+  ctx->init_hash (ctx);
+  ctx->update_hash (ctx, pad, ctx->block_size);
+}
+
+static void
+hmac_update(const hmac_context *ctx,
+            const uint8_t *message,
+            unsigned message_size)
+{
+  ctx->update_hash (ctx, message, message_size);
+}
+
+static void
+hmac_finish(const hmac_context *ctx,
+            const uint8_t *K,
+            uint8_t *result)
+{
+  uint8_t *pad = ctx->tmp + 2 * ctx->result_size;
+  unsigned i;
+  for (i = 0; i < ctx->result_size; ++i)
+    pad[i] = K[i] ^ 0x5c;
+  for (; i < ctx->block_size; ++i)
+    pad[i] = 0x5c;
+
+  ctx->finish_hash (ctx, result);
+
+  ctx->init_hash (ctx);
+  ctx->update_hash (ctx, pad, ctx->block_size);
+  ctx->update_hash (ctx, result, ctx->result_size);
+  ctx->finish_hash (ctx, result);
+}
+
+void
+hmac_sha256_init (hmac_sha256_context *ctx, const uint8_t *K)
+{
+  ctx->hmac_ctx.init_hash = _hmac_sha256_init;
+  ctx->hmac_ctx.update_hash = _hmac_sha256_update;
+  ctx->hmac_ctx.finish_hash = _hmac_sha256_finish;
+  ctx->hmac_ctx.block_size = 64;
+  ctx->hmac_ctx.result_size = 32;
+  ctx->hmac_ctx.tmp = ctx->tmp;
+  hmac_init (&ctx->hmac_ctx, K);
+}
+
+void
+hmac_sha256_update (const hmac_sha256_context *ctx, const uint8_t *message,
+                    unsigned message_size)
+{
+  hmac_update (&ctx->hmac_ctx, message, message_size);
+}
+
+void
+hmac_sha256_finish (const hmac_sha256_context *ctx, const uint8_t *K,
+                    uint8_t *hash_result)
+{
+  hmac_finish (&ctx->hmac_ctx, K, hash_result);
+}
diff --git a/lib/toolbox/hmac_sha256.h b/lib/toolbox/hmac_sha256.h
new file mode 100644
index 00000000..c4c8d98a
--- /dev/null
+++ b/lib/toolbox/hmac_sha256.h
@@ -0,0 +1,29 @@
+
+typedef struct hmac_context {
+  void (*init_hash)(const struct hmac_context *context);
+  void (*update_hash)(const struct hmac_context *context,
+                      const uint8_t *message,
+                      unsigned message_size);
+  void (*finish_hash)(const struct hmac_context *context, uint8_t *hash_result);
+  unsigned block_size; /* Hash function block size in bytes, eg 64 for SHA-256. */
+  unsigned result_size; /* Hash function result size in bytes, eg 32 for SHA-256. */
+  uint8_t *tmp; /* Must point to a buffer of at least (2 * result_size + block_size) bytes. */
+} hmac_context;
+
+
+typedef struct hmac_sha256_context {
+  hmac_context hmac_ctx;
+  sha256_context sha_ctx;
+  uint8_t tmp[32 * 2 + 64];
+} hmac_sha256_context;
+
+void
+hmac_sha256_init (hmac_sha256_context *ctx, const uint8_t *K);
+
+void
+hmac_sha256_update (const hmac_sha256_context *ctx, const uint8_t *message,
+                    unsigned message_size);
+
+void
+hmac_sha256_finish (const hmac_sha256_context *ctx, const uint8_t *K,
+                    uint8_t *hash_result);
diff --git a/lib/toolbox/sha256.c b/lib/toolbox/sha256.c
new file mode 100644
index 00000000..a44e22e1
--- /dev/null
+++ b/lib/toolbox/sha256.c
@@ -0,0 +1,226 @@
+/*
+ * sha256.c -- Compute SHA-256 hash
+ *
+ * Just for little endian architecture.
+ *
+ * Code taken from:
+ *  http://gladman.plushost.co.uk/oldsite/cryptography_technology/sha/index.php
+ *
+ *  File names are sha2.c, sha2.h, brg_types.h, brg_endian.h
+ *  in the archive sha2-07-01-07.zip.
+ *
+ * Code is modified in the style of PolarSSL API.
+ *
+ * See original copyright notice below.
+ */
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 2002, Dr Brian Gladman, Worcester, UK.   All rights reserved.
+
+ LICENSE TERMS
+
+ The free distribution and use of this software in both source and binary
+ form is allowed (with or without changes) provided that:
+
+   1. distributions of this source code include the above copyright
+      notice, this list of conditions and the following disclaimer;
+
+   2. distributions in binary form include the above copyright
+      notice, this list of conditions and the following disclaimer
+      in the documentation and/or other associated materials;
+
+   3. the copyright holder's name is not used to endorse products
+      built using this software without specific written permission.
+
+ ALTERNATIVELY, provided that this notice is retained in full, this product
+ may be distributed under the terms of the GNU General Public License (GPL),
+ in which case the provisions of the GPL apply INSTEAD OF those given above.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 01/08/2005
+*/
+
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "sha256.h"
+
+#define SHA256_MASK (SHA256_BLOCK_SIZE - 1)
+
+static void memcpy_output_bswap32 (unsigned char *dst, const uint32_t *p)
+{
+  int i;
+  uint32_t q = 0;
+
+  for (i = 0; i < 32; i++)
+    {
+      if ((i & 3) == 0)
+	q = __builtin_bswap32 (p[i >> 2]); /* bswap32 is GCC extention */
+      dst[i] = q >> ((i & 3) * 8);
+    }
+}
+
+#define rotr32(x,n)   (((x) >> n) | ((x) << (32 - n)))
+
+#define ch(x,y,z)       ((z) ^ ((x) & ((y) ^ (z))))
+#define maj(x,y,z)      (((x) & (y)) | ((z) & ((x) ^ (y))))
+
+/* round transforms for SHA256 compression functions */
+#define vf(n,i) v[(n - i) & 7]
+
+#define hf(i) (p[i & 15] += \
+    g_1(p[(i + 14) & 15]) + p[(i + 9) & 15] + g_0(p[(i + 1) & 15]))
+
+#define v_cycle0(i)                                 \
+    p[i] = __builtin_bswap32 (p[i]);                \
+    vf(7,i) += p[i] + k_0[i]                        \
+    + s_1(vf(4,i)) + ch(vf(4,i),vf(5,i),vf(6,i));   \
+    vf(3,i) += vf(7,i);                             \
+    vf(7,i) += s_0(vf(0,i))+ maj(vf(0,i),vf(1,i),vf(2,i))
+
+#define v_cycle(i, j)                               \
+    vf(7,i) += hf(i) + k_0[i+j]                     \
+    + s_1(vf(4,i)) + ch(vf(4,i),vf(5,i),vf(6,i));   \
+    vf(3,i) += vf(7,i);                             \
+    vf(7,i) += s_0(vf(0,i))+ maj(vf(0,i),vf(1,i),vf(2,i))
+
+#define s_0(x)  (rotr32((x),  2) ^ rotr32((x), 13) ^ rotr32((x), 22))
+#define s_1(x)  (rotr32((x),  6) ^ rotr32((x), 11) ^ rotr32((x), 25))
+#define g_0(x)  (rotr32((x),  7) ^ rotr32((x), 18) ^ ((x) >>  3))
+#define g_1(x)  (rotr32((x), 17) ^ rotr32((x), 19) ^ ((x) >> 10))
+#define k_0     k256
+
+static const uint32_t k256[64] = {
+  0X428A2F98, 0X71374491, 0XB5C0FBCF, 0XE9B5DBA5,
+  0X3956C25B, 0X59F111F1, 0X923F82A4, 0XAB1C5ED5,
+  0XD807AA98, 0X12835B01, 0X243185BE, 0X550C7DC3,
+  0X72BE5D74, 0X80DEB1FE, 0X9BDC06A7, 0XC19BF174,
+  0XE49B69C1, 0XEFBE4786, 0X0FC19DC6, 0X240CA1CC,
+  0X2DE92C6F, 0X4A7484AA, 0X5CB0A9DC, 0X76F988DA,
+  0X983E5152, 0XA831C66D, 0XB00327C8, 0XBF597FC7,
+  0XC6E00BF3, 0XD5A79147, 0X06CA6351, 0X14292967,
+  0X27B70A85, 0X2E1B2138, 0X4D2C6DFC, 0X53380D13,
+  0X650A7354, 0X766A0ABB, 0X81C2C92E, 0X92722C85,
+  0XA2BFE8A1, 0XA81A664B, 0XC24B8B70, 0XC76C51A3,
+  0XD192E819, 0XD6990624, 0XF40E3585, 0X106AA070,
+  0X19A4C116, 0X1E376C08, 0X2748774C, 0X34B0BCB5,
+  0X391C0CB3, 0X4ED8AA4A, 0X5B9CCA4F, 0X682E6FF3,
+  0X748F82EE, 0X78A5636F, 0X84C87814, 0X8CC70208,
+  0X90BEFFFA, 0XA4506CEB, 0XBEF9A3F7, 0XC67178F2,
+};
+
+void
+sha256_process (sha256_context *ctx)
+{
+  uint32_t i;
+  uint32_t *p = ctx->wbuf;
+  uint32_t v[8];
+
+  memcpy (v, ctx->state, 8 * sizeof (uint32_t));
+
+  v_cycle0 ( 0); v_cycle0 ( 1); v_cycle0 ( 2); v_cycle0 ( 3);
+  v_cycle0 ( 4); v_cycle0 ( 5); v_cycle0 ( 6); v_cycle0 ( 7);
+  v_cycle0 ( 8); v_cycle0 ( 9); v_cycle0 (10); v_cycle0 (11);
+  v_cycle0 (12); v_cycle0 (13); v_cycle0 (14); v_cycle0 (15);
+
+  for (i = 16; i < 64; i += 16)
+    {
+      v_cycle ( 0, i); v_cycle ( 1, i); v_cycle ( 2, i); v_cycle ( 3, i);
+      v_cycle ( 4, i); v_cycle ( 5, i); v_cycle ( 6, i); v_cycle ( 7, i);
+      v_cycle ( 8, i); v_cycle ( 9, i); v_cycle (10, i); v_cycle (11, i);
+      v_cycle (12, i); v_cycle (13, i); v_cycle (14, i); v_cycle (15, i);
+    }
+
+  ctx->state[0] += v[0];
+  ctx->state[1] += v[1];
+  ctx->state[2] += v[2];
+  ctx->state[3] += v[3];
+  ctx->state[4] += v[4];
+  ctx->state[5] += v[5];
+  ctx->state[6] += v[6];
+  ctx->state[7] += v[7];
+}
+
+void
+sha256_update (sha256_context *ctx, const unsigned char *input,
+               unsigned int ilen)
+{
+  uint32_t left = (ctx->total[0] & SHA256_MASK);
+  uint32_t fill = SHA256_BLOCK_SIZE - left;
+
+  ctx->total[0] += ilen;
+  if (ctx->total[0] < ilen)
+    ctx->total[1]++;
+
+  while (ilen >= fill)
+    {
+      memcpy (((unsigned char*)ctx->wbuf) + left, input, fill);
+      sha256_process (ctx);
+      input += fill;
+      ilen -= fill;
+      left = 0;
+      fill = SHA256_BLOCK_SIZE;
+    }
+
+  memcpy (((unsigned char*)ctx->wbuf) + left, input, ilen);
+}
+
+void
+sha256_finish (sha256_context *ctx, unsigned char output[32])
+{
+  uint32_t last = (ctx->total[0] & SHA256_MASK);
+
+  ctx->wbuf[last >> 2] = __builtin_bswap32 (ctx->wbuf[last >> 2]);
+  ctx->wbuf[last >> 2] &= 0xffffff80 << (8 * (~last & 3));
+  ctx->wbuf[last >> 2] |= 0x00000080 << (8 * (~last & 3));
+  ctx->wbuf[last >> 2] = __builtin_bswap32 (ctx->wbuf[last >> 2]);
+
+  if (last > SHA256_BLOCK_SIZE - 9)
+    {
+      if (last < 60)
+        ctx->wbuf[15] = 0;
+      sha256_process (ctx);
+      last = 0;
+    }
+  else
+    last = (last >> 2) + 1;
+
+  while (last < 14)
+    ctx->wbuf[last++] = 0;
+
+  ctx->wbuf[14] = __builtin_bswap32 ((ctx->total[0] >> 29) | (ctx->total[1] << 3));
+  ctx->wbuf[15] = __builtin_bswap32 (ctx->total[0] << 3);
+  sha256_process (ctx);
+
+  memcpy_output_bswap32 (output, ctx->state);
+  memset (ctx, 0, sizeof (sha256_context));
+}
+
+static const uint32_t initial_state[8] =
+{
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+};
+
+void
+sha256_start (sha256_context *ctx)
+{
+  ctx->total[0] = ctx->total[1] = 0;
+  memcpy (ctx->state, initial_state, 8 * sizeof(uint32_t));
+}
+
+void
+sha256 (const unsigned char *input, unsigned int ilen,
+        unsigned char output[32])
+{
+  sha256_context ctx;
+
+  sha256_start (&ctx);
+  sha256_update (&ctx, input, ilen);
+  sha256_finish (&ctx, output);
+}
diff --git a/lib/toolbox/sha256.h b/lib/toolbox/sha256.h
new file mode 100644
index 00000000..1454c3f5
--- /dev/null
+++ b/lib/toolbox/sha256.h
@@ -0,0 +1,17 @@
+#define SHA256_DIGEST_SIZE  32
+#define SHA256_BLOCK_SIZE   64
+
+typedef struct
+{
+  uint32_t total[2];
+  uint32_t state[8];
+  uint32_t wbuf[16];
+} sha256_context;
+
+void sha256 (const unsigned char *input, unsigned int ilen,
+	     unsigned char output[32]);
+void sha256_start (sha256_context *ctx);
+void sha256_finish (sha256_context *ctx, unsigned char output[32]);
+void sha256_update (sha256_context *ctx, const unsigned char *input,
+		    unsigned int ilen);
+void sha256_process (sha256_context *ctx);