diff --git a/cbits/text.c b/cbits/text.c
--- a/cbits/text.c
+++ b/cbits/text.c
@@ -13,6 +13,7 @@
 #include <stdint.h>
 #include <stdio.h>
 
+
 uint8_t* encode_text
 (
   uint8_t *dest,
@@ -20,11 +21,73 @@
   size_t src_offset,
   size_t src_length
 )
+#if defined(__x86_64__)
 {
 
   src += src_offset;
   
   const uint16_t* src_end = src + src_length;
+  const uint16_t* full_word_src_end = src_end - 4;
+
+  while (src < src_end) {
+    uint16_t x = *src++;
+
+    if (x <= 0x7F) {
+      *dest++ = x;
+
+      while (src < full_word_src_end) {
+        uint64_t x = *((uint64_t *) src);
+
+        if (x & 0xFF80FF80FF80FF80ULL) {
+          if (!(x & 0x000000000000FF80ULL)) {
+            *dest++ = x & 0xFFFF;
+            src++;
+            if (!(x & 0x00000000FF800000ULL)) {
+              *dest++ = (x >> 16) & 0xFFFF;
+              src++;
+              if (!(x & 0x0000FF8000000000ULL)) {
+                *dest++ = (x >> 32) & 0xFFFF;
+                src++;
+              }
+            }
+          }
+          break;
+        }
+        
+        *dest++ = x & 0xFFFF;
+        *dest++ = (x >> 16) & 0xFFFF;
+        *dest++ = (x >> 32) & 0xFFFF;
+        *dest++ = x >> 48;
+        src += 4;
+      }
+    }
+    else if (x <= 0x7FF) {
+      *dest++ = (x >> 6) | 0xC0;
+      *dest++ = (x & 0x3f) | 0x80;
+    }
+    else if (x < 0xD800 || x > 0xDBFF) {
+      *dest++ = (x >> 12) | 0xE0;
+      *dest++ = ((x >> 6) & 0x3F) | 0x80;
+      *dest++ = (x & 0x3F) | 0x80;
+    } else {
+      uint32_t c =
+        ((((uint32_t) x) - 0xD800) << 10) + 
+        (((uint32_t) *src++) - 0xDC00) + 0x10000;
+      *dest++ = (c >> 18) | 0xF0;
+      *dest++ = ((c >> 12) & 0x3F) | 0x80;
+      *dest++ = ((c >> 6) & 0x3F) | 0x80;
+      *dest++ = (c & 0x3F) | 0x80;
+    }
+  }
+
+  return dest;
+}
+#else
+{
+
+  src += src_offset;
+  
+  const uint16_t* src_end = src + src_length;
   const uint16_t* full_word_src_end = src_end - 2;
 
   while (src < src_end) {
@@ -65,6 +128,7 @@
 
   return dest;
 }
+#endif
 
 
 int count_text_allocation_size
@@ -73,10 +137,64 @@
   size_t src_off,
   size_t src_len
 )
+#if defined(__x86_64__)
 {
   src_ptr += src_off;
 
   const uint16_t* after_src_ptr = src_ptr + src_len;
+  const uint16_t* full_word_after_src_ptr = after_src_ptr - 4;
+
+  size_t size = 0;
+
+  while (src_ptr < after_src_ptr) {
+    uint16_t w = *src_ptr++;
+
+    if (w <= 0x7F) {
+      size += 1;
+
+      /* Try to go in batches of 4 bytes. */
+      while (src_ptr < full_word_after_src_ptr) {
+        uint64_t x = *((uint64_t*) src_ptr);
+
+        if (x & 0xFF80FF80FF80FF80ULL) {
+          if (!(x & 0x000000000000FF80ULL)) {
+            size++;
+            src_ptr++;
+            if (!(x & 0x00000000FF800000ULL)) {
+              size++;
+              src_ptr++;
+              if (!(x & 0x0000FF8000000000ULL)) {
+                size++;
+                src_ptr++;
+              }
+            }
+          }
+          break;
+        }
+        
+        size += 4;
+        src_ptr += 4;
+      }
+
+    }
+    else if (w <= 0x7FF) {
+      size += 2;
+    }
+    else if (w < 0xD800 || w > 0xDBFF) {
+      size += 3;
+    } else {
+      src_ptr++;
+      size += 4;
+    }
+  }
+
+  return size;
+}
+#else
+{
+  src_ptr += src_off;
+
+  const uint16_t* after_src_ptr = src_ptr + src_len;
   const uint16_t* full_word_after_src_ptr = after_src_ptr - 2;
 
   size_t size = 0;
@@ -111,3 +229,4 @@
 
   return size;
 }
+#endif
diff --git a/ptr-poker.cabal b/ptr-poker.cabal
--- a/ptr-poker.cabal
+++ b/ptr-poker.cabal
@@ -1,5 +1,5 @@
 name: ptr-poker
-version: 0.1.2.7
+version: 0.1.2.8
 synopsis: Pointer poking action construction and composition toolkit
 homepage: https://github.com/nikita-volkov/ptr-poker
 bug-reports: https://github.com/nikita-volkov/ptr-poker/issues