From 80607a827aec830c2da51cdecd385eb04e3886b8 Mon Sep 17 00:00:00 2001
From: Rom <chanphiromsok2109@gmail.com>
Date: Sun, 17 May 2026 07:44:28 +0700
Subject: [PATCH 1/3] feat: update NitroBase64

- json and yarn.lock to upgrade nitrogen and react-native-nitro-modules to version 0.35.6.
---
 README.md                                     |   81 +-
 cpp/NitroBase64.hpp                           |   44 +-
 cpp/simdutf.cpp                               | 8879 +++++++++--------
 cpp/simdutf.h                                 | 6916 ++++++++++++-
 example/Gemfile.lock                          |   22 +-
 .../project.pbxproj                           |   50 +-
 example/ios/Podfile.lock                      |   38 +-
 example/package.json                          |    4 +-
 example/src/Benchmark.tsx                     |   10 +-
 example/src/Benchmark2.tsx                    |  452 +-
 nitro.json                                    |    5 +-
 .../android/NitroBase64+autolinking.cmake     |    2 +-
 .../android/NitroBase64+autolinking.gradle    |    2 +-
 .../generated/android/NitroBase64OnLoad.cpp   |   41 +-
 .../generated/android/NitroBase64OnLoad.hpp   |   19 +-
 .../nitro/nitrobase64/NitroBase64OnLoad.kt    |    2 +-
 .../generated/ios/NitroBase64+autolinking.rb  |    6 +-
 .../ios/NitroBase64-Swift-Cxx-Bridge.cpp      |    2 +-
 .../ios/NitroBase64-Swift-Cxx-Bridge.hpp      |    2 +-
 .../ios/NitroBase64-Swift-Cxx-Umbrella.hpp    |    2 +-
 .../generated/ios/NitroBase64Autolinking.mm   |    2 +-
 .../ios/NitroBase64Autolinking.swift          |    6 +-
 .../shared/c++/HybridNitroBase64Spec.cpp      |    4 +-
 .../shared/c++/HybridNitroBase64Spec.hpp      |    7 +-
 package.json                                  |    6 +-
 src/NitroBase64.nitro.ts                      |    4 +-
 src/index.tsx                                 |   23 +-
 yarn.lock                                     |  108 +-
 28 files changed, 11915 insertions(+), 4824 deletions(-)

diff --git a/README.md b/README.md
index 79c3ca3..660bcef 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ A high-performance, cross-platform Base64 encoding/decoding module for React Nat
 
 ```sh
 yarn add react-native-nitro-base64
-yarn add react-native-nitro-modules@0.29.8
+yarn add react-native-nitro-modules
 ```
 
 ### Linking
@@ -24,39 +24,72 @@ This module uses [react-native-nitro-modules](https://github.com/mrousavy/nitro)
 
 ## API
 
+| Function | Input | Output | Use case |
+|---|---|---|---|
+| `encode(str, urlSafe?)` | binary string | base64 string | Text/JWT encoding |
+| `decode(base64)` | base64 string | binary string | Text/JWT decoding — accepts standard and URL-safe automatically |
+| `encodeBuffer(ArrayBuffer, urlSafe?)` | ArrayBuffer | base64 string | Image/file → base64 |
+| `decodeBuffer(base64)` | base64 string | ArrayBuffer | base64 → raw binary — accepts standard and URL-safe automatically |
+| `fromByteArray(Uint8Array, urlSafe?)` | Uint8Array | base64 string | Crypto/hashing output → base64 |
+| `toByteArray(base64)` | base64 string | Uint8Array | base64 → typed binary — accepts standard and URL-safe automatically |
+
+### Which one should I use?
+
+**Working with images?** Use `encodeBuffer` / `decodeBuffer`.
+
+Images are binary data. Passing them through a JS string crosses the JSI bridge as UTF-16, doubling memory and adding overhead. `ArrayBuffer` avoids that — raw bytes go directly to C++.
+
 ```typescript
-export interface NitroBase64 extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
-  install(): void;
-  encode(input: string, urlSafe: boolean): string;
-  decode(base64: string, urlSafe: boolean): string;
-}
+import { encodeBuffer, decodeBuffer } from 'react-native-nitro-base64';
+import { readFile } from 'react-native-fs';
+
+// Image file → base64 (for API upload)
+const bytes = await readFile(imagePath, 'ascii'); // or use arrayBuffer APIs
+const base64 = encodeBuffer(buffer); // ArrayBuffer → base64
+
+// base64 from API → display in <Image>
+const buffer = decodeBuffer(base64String); // base64 → ArrayBuffer
 ```
 
-- `install(): void` — Initializes the native module for faster first-time encoding/decoding. Call this early in your app lifecycle via index.js or root
-- `encode(input: string, urlSafe: boolean): string` — Encodes binary data to base64. Set `urlSafe` to `true` for base64url encoding.
-- `decode(base64: string, urlSafe: boolean): string` — Decodes base64 (WHATWG forgiving) to binary. Set `urlSafe` to `true` for base64url decoding.
+**Working with text / JWT?** Use `encode` / `decode`.
 
-## Usage
-```javascript
-index.js
-import { install } from 'react-native-nitro-base64';
-import { AppRegistry } from 'react-native';
-import { install } from 'react-native-nitro-base64';
-import { name as appName } from './app.json';
-import App from './src/App';
-install(); // <=== Call
-AppRegistry.registerComponent(appName, () => App);
+```typescript
+import { encode, decode } from 'react-native-nitro-base64';
 
+const encoded = encode('Hello World!'); // "SGVsbG8gV29ybGQh"
+const decoded = decode(encoded);       // "Hello World!"
 
+// URL-safe (JWT, URL params)
+const token = encode(payload, true);
+```
+
+**Working with Web Crypto / hashing?** Use `fromByteArray` / `toByteArray`.
+
+Web Crypto APIs (`crypto.subtle`) return `Uint8Array`. These are drop-in compatible with `react-native-quick-base64`.
 
 ```typescript
-import { encode,decode } from 'react-native-nitro-base64';
+import { fromByteArray, toByteArray } from 'react-native-nitro-base64';
 
-const encoded = encode('Hello World!', false); // "SGVsbG8gV29ybGQh"
-const urlEncoded = encode('Hello World!', true); // "SGVsbG8gV29ybGQh"
+// Hash → base64
+const hash = new Uint8Array(await crypto.subtle.digest('SHA-256', data));
+const encoded = fromByteArray(hash);
 
-const decoded = decode(encoded, false); // "Hello World!"
-const urlDecoded = decode(urlEncoded, true); // "Hello World!"
+// base64 → bytes for TextDecoder
+const bytes = toByteArray(base64String);
+const text = new TextDecoder().decode(bytes);
+```
+
+## Setup
+
+```javascript
+// index.js
+import { install } from 'react-native-nitro-base64';
+import { AppRegistry } from 'react-native';
+import { name as appName } from './app.json';
+import App from './src/App';
+
+install(); // call before app mounts
+AppRegistry.registerComponent(appName, () => App);
 ```
 
 ## Platform Support
diff --git a/cpp/NitroBase64.hpp b/cpp/NitroBase64.hpp
index c33ddcd..f71ce64 100644
--- a/cpp/NitroBase64.hpp
+++ b/cpp/NitroBase64.hpp
@@ -2,6 +2,7 @@
 
 #include "HybridNitroBase64Spec.hpp"
 #include "simdutf.h"
+#include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::nitrobase64 {
     using namespace margelo::nitro;
@@ -27,7 +28,7 @@ namespace margelo::nitro::nitrobase64 {
             return output;
         }
 
-        std::string decode(const std::string &base64,bool urlSafe = false) override {
+        std::string decode(const std::string &base64) override {
             size_t max_decoded_size = simdutf::maximal_binary_length_from_base64(
                 base64.data(),
                 base64.size()
@@ -39,7 +40,7 @@ namespace margelo::nitro::nitrobase64 {
                 base64.data(),
                 base64.size(),
                 output.data(),
-                urlSafe ? simdutf::base64_url : simdutf::base64_default
+                simdutf::base64_default_or_url
             );
 
             if (result.error != simdutf::error_code::SUCCESS) {
@@ -50,6 +51,45 @@ namespace margelo::nitro::nitrobase64 {
             return output;
         }
 
+        std::string encodeBuffer(const std::shared_ptr<ArrayBuffer>& input, bool urlSafe = false) override {
+            auto opts = urlSafe ? simdutf::base64_url : simdutf::base64_default;
+            size_t base64_size = simdutf::base64_length_from_binary(input->size(), opts);
+            std::string output(base64_size, '\0');
+
+            size_t actual_size = simdutf::binary_to_base64(
+                reinterpret_cast<const char*>(input->data()),
+                input->size(),
+                output.data(),
+                opts
+            );
+
+            output.resize(actual_size);
+            return output;
+        }
+
+        std::shared_ptr<ArrayBuffer> decodeBuffer(const std::string &base64) override {
+            size_t max_decoded_size = simdutf::maximal_binary_length_from_base64(
+                base64.data(),
+                base64.size()
+            );
+
+            std::vector<uint8_t> buffer(max_decoded_size);
+
+            auto result = simdutf::base64_to_binary(
+                base64.data(),
+                base64.size(),
+                reinterpret_cast<char*>(buffer.data()),
+                simdutf::base64_default_or_url
+            );
+
+            if (result.error != simdutf::error_code::SUCCESS) {
+                throw std::runtime_error("Base64 decode failed");
+            }
+
+            buffer.resize(result.count);
+            return ArrayBuffer::move(std::move(buffer));
+        }
+
     private:
         static constexpr auto TAG = "NitroBase64";
     };
diff --git a/cpp/simdutf.cpp b/cpp/simdutf.cpp
index 28843c9..5bba36d 100644
--- a/cpp/simdutf.cpp
+++ b/cpp/simdutf.cpp
@@ -1,910 +1,10 @@
-/* auto-generated on 2025-09-10 16:01:38 -0400. Do not edit! */
+/* auto-generated on 2026-05-07 06:54:06 +0200. Do not edit! */
 /* begin file src/simdutf.cpp */
 #include "simdutf.h"
 
-  // We include base64_tables once.
-/* begin file src/tables/base64_tables.h */
-#ifndef SIMDUTF_BASE64_TABLES_H
-#define SIMDUTF_BASE64_TABLES_H
-#include <array>
-#include <cstdint>
-
-namespace simdutf {
-namespace {
-namespace tables {
-namespace base64 {
-namespace base64_default {
-
-const char e0[256] = {
-    'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'D', 'D', 'D',
-    'D', 'E', 'E', 'E', 'E', 'F', 'F', 'F', 'F', 'G', 'G', 'G', 'G', 'H', 'H',
-    'H', 'H', 'I', 'I', 'I', 'I', 'J', 'J', 'J', 'J', 'K', 'K', 'K', 'K', 'L',
-    'L', 'L', 'L', 'M', 'M', 'M', 'M', 'N', 'N', 'N', 'N', 'O', 'O', 'O', 'O',
-    'P', 'P', 'P', 'P', 'Q', 'Q', 'Q', 'Q', 'R', 'R', 'R', 'R', 'S', 'S', 'S',
-    'S', 'T', 'T', 'T', 'T', 'U', 'U', 'U', 'U', 'V', 'V', 'V', 'V', 'W', 'W',
-    'W', 'W', 'X', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'Z', 'a',
-    'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'd', 'd',
-    'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g', 'g', 'h', 'h', 'h',
-    'h', 'i', 'i', 'i', 'i', 'j', 'j', 'j', 'j', 'k', 'k', 'k', 'k', 'l', 'l',
-    'l', 'l', 'm', 'm', 'm', 'm', 'n', 'n', 'n', 'n', 'o', 'o', 'o', 'o', 'p',
-    'p', 'p', 'p', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 's', 's', 's', 's',
-    't', 't', 't', 't', 'u', 'u', 'u', 'u', 'v', 'v', 'v', 'v', 'w', 'w', 'w',
-    'w', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'z', 'z', 'z', 'z', '0', '0',
-    '0', '0', '1', '1', '1', '1', '2', '2', '2', '2', '3', '3', '3', '3', '4',
-    '4', '4', '4', '5', '5', '5', '5', '6', '6', '6', '6', '7', '7', '7', '7',
-    '8', '8', '8', '8', '9', '9', '9', '9', '+', '+', '+', '+', '/', '/', '/',
-    '/'};
-
-const char e1[256] = {
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
-    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
-    '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
-    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C',
-    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
-    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
-    '/'};
-
-const char e2[256] = {
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
-    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
-    '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
-    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C',
-    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
-    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
-    '/'};
-
-const uint32_t d0[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x000000f8, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
-    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
-    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
-    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
-    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
-    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
-    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
-    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
-    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
-    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
-    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-const uint32_t d1[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x0000e003, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
-    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
-    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
-    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
-    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
-    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
-    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
-    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
-    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
-    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
-    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-const uint32_t d2[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00800f00, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
-    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
-    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
-    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
-    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
-    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
-    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
-    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
-    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
-    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
-    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-
-const uint32_t d3[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x003e0000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
-    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
-    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
-    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
-    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
-    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
-    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
-    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
-    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
-    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
-    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-} // namespace base64_default
-
-namespace base64_url {
-
-const char e0[256] = {
-    'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'D', 'D', 'D',
-    'D', 'E', 'E', 'E', 'E', 'F', 'F', 'F', 'F', 'G', 'G', 'G', 'G', 'H', 'H',
-    'H', 'H', 'I', 'I', 'I', 'I', 'J', 'J', 'J', 'J', 'K', 'K', 'K', 'K', 'L',
-    'L', 'L', 'L', 'M', 'M', 'M', 'M', 'N', 'N', 'N', 'N', 'O', 'O', 'O', 'O',
-    'P', 'P', 'P', 'P', 'Q', 'Q', 'Q', 'Q', 'R', 'R', 'R', 'R', 'S', 'S', 'S',
-    'S', 'T', 'T', 'T', 'T', 'U', 'U', 'U', 'U', 'V', 'V', 'V', 'V', 'W', 'W',
-    'W', 'W', 'X', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'Z', 'a',
-    'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'd', 'd',
-    'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g', 'g', 'h', 'h', 'h',
-    'h', 'i', 'i', 'i', 'i', 'j', 'j', 'j', 'j', 'k', 'k', 'k', 'k', 'l', 'l',
-    'l', 'l', 'm', 'm', 'm', 'm', 'n', 'n', 'n', 'n', 'o', 'o', 'o', 'o', 'p',
-    'p', 'p', 'p', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 's', 's', 's', 's',
-    't', 't', 't', 't', 'u', 'u', 'u', 'u', 'v', 'v', 'v', 'v', 'w', 'w', 'w',
-    'w', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'z', 'z', 'z', 'z', '0', '0',
-    '0', '0', '1', '1', '1', '1', '2', '2', '2', '2', '3', '3', '3', '3', '4',
-    '4', '4', '4', '5', '5', '5', '5', '6', '6', '6', '6', '7', '7', '7', '7',
-    '8', '8', '8', '8', '9', '9', '9', '9', '-', '-', '-', '-', '_', '_', '_',
-    '_'};
-
-const char e1[256] = {
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
-    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
-    '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
-    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C',
-    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
-    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-',
-    '_'};
-
-const char e2[256] = {
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
-    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
-    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
-    '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
-    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
-    '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
-    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
-    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
-    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C',
-    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
-    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
-    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-',
-    '_'};
-
-const uint32_t d0[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000f8, 0x01ffffff, 0x01ffffff,
-    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
-    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
-    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
-    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
-    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
-    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
-    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
-    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
-    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
-    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
-    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-const uint32_t d1[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000e003, 0x01ffffff, 0x01ffffff,
-    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
-    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
-    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
-    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
-    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
-    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
-    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
-    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
-    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
-    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
-    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-const uint32_t d2[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00800f00, 0x01ffffff, 0x01ffffff,
-    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
-    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
-    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
-    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
-    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
-    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
-    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
-    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
-    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
-    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
-    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-const uint32_t d3[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003e0000, 0x01ffffff, 0x01ffffff,
-    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
-    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
-    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
-    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
-    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
-    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
-    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
-    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
-    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
-    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
-    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-} // namespace base64_url
-
-namespace base64_default_or_url {
-const uint32_t d0[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x000000f8, 0x01ffffff, 0x000000f8, 0x01ffffff, 0x000000fc,
-    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
-    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
-    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
-    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
-    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
-    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
-    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
-    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
-    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
-    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
-    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-const uint32_t d1[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x0000e003, 0x01ffffff, 0x0000e003, 0x01ffffff, 0x0000f003,
-    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
-    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
-    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
-    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
-    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
-    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
-    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
-    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
-    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
-    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
-    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-const uint32_t d2[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x00800f00, 0x01ffffff, 0x00800f00, 0x01ffffff, 0x00c00f00,
-    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
-    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
-    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
-    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
-    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
-    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
-    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
-    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
-    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
-    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
-    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-const uint32_t d3[256] = {
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x003e0000, 0x01ffffff, 0x003e0000, 0x01ffffff, 0x003f0000,
-    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
-    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
-    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
-    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
-    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
-    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
-    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
-    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
-    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
-    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
-    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
-    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
-    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
-} // namespace base64_default_or_url
-const uint64_t thintable_epi8[256] = {
-    0x0706050403020100, 0x0007060504030201, 0x0007060504030200,
-    0x0000070605040302, 0x0007060504030100, 0x0000070605040301,
-    0x0000070605040300, 0x0000000706050403, 0x0007060504020100,
-    0x0000070605040201, 0x0000070605040200, 0x0000000706050402,
-    0x0000070605040100, 0x0000000706050401, 0x0000000706050400,
-    0x0000000007060504, 0x0007060503020100, 0x0000070605030201,
-    0x0000070605030200, 0x0000000706050302, 0x0000070605030100,
-    0x0000000706050301, 0x0000000706050300, 0x0000000007060503,
-    0x0000070605020100, 0x0000000706050201, 0x0000000706050200,
-    0x0000000007060502, 0x0000000706050100, 0x0000000007060501,
-    0x0000000007060500, 0x0000000000070605, 0x0007060403020100,
-    0x0000070604030201, 0x0000070604030200, 0x0000000706040302,
-    0x0000070604030100, 0x0000000706040301, 0x0000000706040300,
-    0x0000000007060403, 0x0000070604020100, 0x0000000706040201,
-    0x0000000706040200, 0x0000000007060402, 0x0000000706040100,
-    0x0000000007060401, 0x0000000007060400, 0x0000000000070604,
-    0x0000070603020100, 0x0000000706030201, 0x0000000706030200,
-    0x0000000007060302, 0x0000000706030100, 0x0000000007060301,
-    0x0000000007060300, 0x0000000000070603, 0x0000000706020100,
-    0x0000000007060201, 0x0000000007060200, 0x0000000000070602,
-    0x0000000007060100, 0x0000000000070601, 0x0000000000070600,
-    0x0000000000000706, 0x0007050403020100, 0x0000070504030201,
-    0x0000070504030200, 0x0000000705040302, 0x0000070504030100,
-    0x0000000705040301, 0x0000000705040300, 0x0000000007050403,
-    0x0000070504020100, 0x0000000705040201, 0x0000000705040200,
-    0x0000000007050402, 0x0000000705040100, 0x0000000007050401,
-    0x0000000007050400, 0x0000000000070504, 0x0000070503020100,
-    0x0000000705030201, 0x0000000705030200, 0x0000000007050302,
-    0x0000000705030100, 0x0000000007050301, 0x0000000007050300,
-    0x0000000000070503, 0x0000000705020100, 0x0000000007050201,
-    0x0000000007050200, 0x0000000000070502, 0x0000000007050100,
-    0x0000000000070501, 0x0000000000070500, 0x0000000000000705,
-    0x0000070403020100, 0x0000000704030201, 0x0000000704030200,
-    0x0000000007040302, 0x0000000704030100, 0x0000000007040301,
-    0x0000000007040300, 0x0000000000070403, 0x0000000704020100,
-    0x0000000007040201, 0x0000000007040200, 0x0000000000070402,
-    0x0000000007040100, 0x0000000000070401, 0x0000000000070400,
-    0x0000000000000704, 0x0000000703020100, 0x0000000007030201,
-    0x0000000007030200, 0x0000000000070302, 0x0000000007030100,
-    0x0000000000070301, 0x0000000000070300, 0x0000000000000703,
-    0x0000000007020100, 0x0000000000070201, 0x0000000000070200,
-    0x0000000000000702, 0x0000000000070100, 0x0000000000000701,
-    0x0000000000000700, 0x0000000000000007, 0x0006050403020100,
-    0x0000060504030201, 0x0000060504030200, 0x0000000605040302,
-    0x0000060504030100, 0x0000000605040301, 0x0000000605040300,
-    0x0000000006050403, 0x0000060504020100, 0x0000000605040201,
-    0x0000000605040200, 0x0000000006050402, 0x0000000605040100,
-    0x0000000006050401, 0x0000000006050400, 0x0000000000060504,
-    0x0000060503020100, 0x0000000605030201, 0x0000000605030200,
-    0x0000000006050302, 0x0000000605030100, 0x0000000006050301,
-    0x0000000006050300, 0x0000000000060503, 0x0000000605020100,
-    0x0000000006050201, 0x0000000006050200, 0x0000000000060502,
-    0x0000000006050100, 0x0000000000060501, 0x0000000000060500,
-    0x0000000000000605, 0x0000060403020100, 0x0000000604030201,
-    0x0000000604030200, 0x0000000006040302, 0x0000000604030100,
-    0x0000000006040301, 0x0000000006040300, 0x0000000000060403,
-    0x0000000604020100, 0x0000000006040201, 0x0000000006040200,
-    0x0000000000060402, 0x0000000006040100, 0x0000000000060401,
-    0x0000000000060400, 0x0000000000000604, 0x0000000603020100,
-    0x0000000006030201, 0x0000000006030200, 0x0000000000060302,
-    0x0000000006030100, 0x0000000000060301, 0x0000000000060300,
-    0x0000000000000603, 0x0000000006020100, 0x0000000000060201,
-    0x0000000000060200, 0x0000000000000602, 0x0000000000060100,
-    0x0000000000000601, 0x0000000000000600, 0x0000000000000006,
-    0x0000050403020100, 0x0000000504030201, 0x0000000504030200,
-    0x0000000005040302, 0x0000000504030100, 0x0000000005040301,
-    0x0000000005040300, 0x0000000000050403, 0x0000000504020100,
-    0x0000000005040201, 0x0000000005040200, 0x0000000000050402,
-    0x0000000005040100, 0x0000000000050401, 0x0000000000050400,
-    0x0000000000000504, 0x0000000503020100, 0x0000000005030201,
-    0x0000000005030200, 0x0000000000050302, 0x0000000005030100,
-    0x0000000000050301, 0x0000000000050300, 0x0000000000000503,
-    0x0000000005020100, 0x0000000000050201, 0x0000000000050200,
-    0x0000000000000502, 0x0000000000050100, 0x0000000000000501,
-    0x0000000000000500, 0x0000000000000005, 0x0000000403020100,
-    0x0000000004030201, 0x0000000004030200, 0x0000000000040302,
-    0x0000000004030100, 0x0000000000040301, 0x0000000000040300,
-    0x0000000000000403, 0x0000000004020100, 0x0000000000040201,
-    0x0000000000040200, 0x0000000000000402, 0x0000000000040100,
-    0x0000000000000401, 0x0000000000000400, 0x0000000000000004,
-    0x0000000003020100, 0x0000000000030201, 0x0000000000030200,
-    0x0000000000000302, 0x0000000000030100, 0x0000000000000301,
-    0x0000000000000300, 0x0000000000000003, 0x0000000000020100,
-    0x0000000000000201, 0x0000000000000200, 0x0000000000000002,
-    0x0000000000000100, 0x0000000000000001, 0x0000000000000000,
-    0x0000000000000000,
-};
-
-const uint8_t pshufb_combine_table[272] = {
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-    0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
-    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0x00, 0x01, 0x02, 0x03,
-    0x04, 0x05, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff,
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
-    0x0f, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0a, 0x0b,
-    0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x08,
-    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0x00, 0x01, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0x00, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
-    0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x08, 0x09, 0x0a, 0x0b,
-    0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-};
-
-const unsigned char BitsSetTable256mul2[256] = {
-    0,  2,  2,  4,  2,  4,  4,  6,  2,  4,  4,  6,  4,  6,  6,  8,  2,  4,  4,
-    6,  4,  6,  6,  8,  4,  6,  6,  8,  6,  8,  8,  10, 2,  4,  4,  6,  4,  6,
-    6,  8,  4,  6,  6,  8,  6,  8,  8,  10, 4,  6,  6,  8,  6,  8,  8,  10, 6,
-    8,  8,  10, 8,  10, 10, 12, 2,  4,  4,  6,  4,  6,  6,  8,  4,  6,  6,  8,
-    6,  8,  8,  10, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,  10, 8,  10, 10,
-    12, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,  10, 8,  10, 10, 12, 6,  8,
-    8,  10, 8,  10, 10, 12, 8,  10, 10, 12, 10, 12, 12, 14, 2,  4,  4,  6,  4,
-    6,  6,  8,  4,  6,  6,  8,  6,  8,  8,  10, 4,  6,  6,  8,  6,  8,  8,  10,
-    6,  8,  8,  10, 8,  10, 10, 12, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,
-    10, 8,  10, 10, 12, 6,  8,  8,  10, 8,  10, 10, 12, 8,  10, 10, 12, 10, 12,
-    12, 14, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,  10, 8,  10, 10, 12, 6,
-    8,  8,  10, 8,  10, 10, 12, 8,  10, 10, 12, 10, 12, 12, 14, 6,  8,  8,  10,
-    8,  10, 10, 12, 8,  10, 10, 12, 10, 12, 12, 14, 8,  10, 10, 12, 10, 12, 12,
-    14, 10, 12, 12, 14, 12, 14, 14, 16};
-
-constexpr uint8_t to_base64_value[] = {
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
-    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
-    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
-    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
-    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33,
-    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
-    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255};
-
-constexpr uint8_t to_base64_url_value[] = {
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    62,  255, 255, 52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
-    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
-    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
-    25,  255, 255, 255, 255, 63,  255, 26,  27,  28,  29,  30,  31,  32,  33,
-    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
-    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255};
-
-constexpr uint8_t to_base64_default_or_url_value[] = {
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
-    62,  255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
-    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
-    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
-    25,  255, 255, 255, 255, 63,  255, 26,  27,  28,  29,  30,  31,  32,  33,
-    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
-    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255};
-
-static_assert(sizeof(to_base64_value) == 256,
-              "to_base64_value must have 256 elements");
-static_assert(sizeof(to_base64_url_value) == 256,
-              "to_base64_url_value must have 256 elements");
-static_assert(to_base64_value[uint8_t(' ')] == 64,
-              "space must be == 64 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t(' ')] == 64,
-              "space must be == 64 in to_base64_url_value");
-static_assert(to_base64_value[uint8_t('\t')] == 64,
-              "tab must be == 64 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t('\t')] == 64,
-              "tab must be == 64 in to_base64_url_value");
-static_assert(to_base64_value[uint8_t('\r')] == 64,
-              "cr must be == 64 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t('\r')] == 64,
-              "cr must be == 64 in to_base64_url_value");
-static_assert(to_base64_value[uint8_t('\n')] == 64,
-              "lf must be == 64 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t('\n')] == 64,
-              "lf must be == 64 in to_base64_url_value");
-static_assert(to_base64_value[uint8_t('\f')] == 64,
-              "ff must be == 64 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t('\f')] == 64,
-              "ff must be == 64 in to_base64_url_value");
-static_assert(to_base64_value[uint8_t('+')] == 62,
-              "+ must be == 62 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t('-')] == 62,
-              "- must be == 62 in to_base64_url_value");
-static_assert(to_base64_value[uint8_t('/')] == 63,
-              "/ must be == 62 in to_base64_value");
-static_assert(to_base64_url_value[uint8_t('_')] == 63,
-              "_ must be == 62 in to_base64_url_value");
-} // namespace base64
-} // namespace tables
-} // unnamed namespace
-} // namespace simdutf
-
-#endif // SIMDUTF_BASE64_TABLES_H
-/* end file src/tables/base64_tables.h */
-
 /* begin file src/encoding_types.cpp */
 namespace simdutf {
-bool match_system(endianness e) {
-#if SIMDUTF_IS_BIG_ENDIAN
-  return e == endianness::BIG;
-#else
-  return e == endianness::LITTLE;
-#endif
-}
-
-std::string to_string(encoding_type bom) {
+std::string_view to_string(encoding_type bom) {
   switch (bom) {
   case UTF16_LE:
     return "UTF16 little-endian";
@@ -2688,27 +1788,35 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override;
 };
 
 } // namespace arm64
@@ -2720,7 +1828,6 @@ class implementation final : public simdutf::implementation {
 /* begin file src/simdutf/arm64/begin.h */
 // redefining SIMDUTF_IMPLEMENTATION to "arm64"
 // #define SIMDUTF_IMPLEMENTATION arm64
-#define SIMDUTF_SIMD_HAS_BYTEMASK 1
 /* end file src/simdutf/arm64/begin.h */
 
   // Declarations
@@ -3082,9 +2189,10 @@ template <> struct simd8<int8_t> {
   //    ...
   template <endianness big_endian>
   simdutf_really_inline void store_ascii_as_utf16(char16_t *p) const {
-    int8x16x2_t pair = match_system(big_endian)
-                           ? int8x16x2_t{{this->value, vmovq_n_s8(0)}}
-                           : int8x16x2_t{{vmovq_n_s8(0), this->value}};
+    constexpr auto matches = match_system(big_endian);
+    const int8x16x2_t pair = matches
+                                 ? int8x16x2_t{{this->value, vmovq_n_s8(0)}}
+                                 : int8x16x2_t{{vmovq_n_s8(0), this->value}};
     vst2q_s8(reinterpret_cast<int8_t *>(p), pair);
   }
 
@@ -3283,6 +2391,12 @@ template <typename T> struct simd8x64 {
                           this->chunks[2] > mask, this->chunks[3] > mask)
         .to_bitmask();
   }
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                          this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
+  }
   simdutf_really_inline uint64_t gteq_unsigned(const uint8_t m) const {
     const simd8<uint8_t> mask = simd8<uint8_t>::splat(m);
     return simd8x64<bool>(simd8<uint8_t>(uint8x16_t(this->chunks[0])) >= mask,
@@ -3652,7 +2766,12 @@ template <typename T> struct simd16x32 {
                            this->chunks[2] > mask, this->chunks[3] > mask)
         .to_bitmask();
   }
-
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                           this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
+  }
   simdutf_really_inline uint64_t lteq(const T m) const {
     const simd16<T> mask = simd16<T>::splat(m);
     return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
@@ -3871,7 +2990,6 @@ simdutf_really_inline simd64<uint64_t> sum_8bytes(const simd8<uint8_t> v) {
 /* end file src/simdutf/arm64/simd.h */
 
 /* begin file src/simdutf/arm64/end.h */
-#undef SIMDUTF_SIMD_HAS_BYTEMASK
 /* end file src/simdutf/arm64/end.h */
 
 #endif // SIMDUTF_IMPLEMENTATION_ARM64
@@ -4113,27 +3231,35 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override;
 };
 
 } // namespace icelake
@@ -4182,6 +3308,17 @@ simdutf_really_inline long long int count_ones(uint64_t input_num) {
 }
 #endif
 
+#ifdef SIMDUTF_REGULAR_VISUAL_STUDIO
+simdutf_really_inline unsigned __int64 count_ones32(uint32_t input_num) {
+  // note: we do not support legacy 32-bit Windows
+  return __popcnt(input_num); // Visual Studio wants two underscores
+}
+#else
+simdutf_really_inline long long int count_ones32(uint32_t input_num) {
+  return _popcnt32(input_num);
+}
+#endif
+
 #if SIMDUTF_NEED_TRAILING_ZEROES
 // simdutf_really_inline int trailing_zeroes(uint64_t input_num) {
 //   #if SIMDUTF_REGULAR_VISUAL_STUDIO
@@ -4445,27 +3582,35 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override;
 };
 
 } // namespace haswell
@@ -5460,27 +4605,35 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override;
 };
 
 } // namespace westmere
@@ -5923,7 +5076,12 @@ template <typename T> struct simd8x64 {
                           this->chunks[2] > mask, this->chunks[3] > mask)
         .to_bitmask();
   }
-
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                          this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
+  }
   simdutf_really_inline uint64_t eq(const T m) const {
     const simd8<T> mask = simd8<T>::splat(m);
     return simd8x64<bool>(this->chunks[0] == mask, this->chunks[1] == mask,
@@ -6155,6 +5313,13 @@ template <typename T> struct simd16x32 {
         .to_bitmask();
   }
 
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                           this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
+  }
+
   simdutf_really_inline uint64_t eq(const T m) const {
     const simd16<T> mask = simd16<T>::splat(m);
     return simd16x32<bool>(this->chunks[0] == mask, this->chunks[1] == mask,
@@ -6448,29 +5613,33 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
 
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
 
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
 
 #ifdef SIMDUTF_INTERNAL_TESTS
   virtual std::vector<TestProcedure> internal_tests() const override;
@@ -7976,28 +7145,32 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
 
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
 private:
   const bool _supports_zvbb;
 
@@ -8170,42 +7343,47 @@ SIMDUTF_UNTARGET_REGION
 
 #endif // SIMDUTF_RVV_H
 /* end file src/simdutf/rvv.h */
-/* begin file src/simdutf/lsx.h */
-#ifndef SIMDUTF_LSX_H
-#define SIMDUTF_LSX_H
+/* begin file src/simdutf/lasx.h */
+#ifndef SIMDUTF_LASX_H
+#define SIMDUTF_LASX_H
 
 #ifdef SIMDUTF_FALLBACK_H
-  #error "lsx.h must be included before fallback.h"
+  #error "lasx.h must be included before fallback.h"
 #endif
 
 
-#ifndef SIMDUTF_IMPLEMENTATION_LSX
-  #define SIMDUTF_IMPLEMENTATION_LSX (SIMDUTF_IS_LSX)
+#ifndef SIMDUTF_IMPLEMENTATION_LASX
+  #define SIMDUTF_IMPLEMENTATION_LASX (SIMDUTF_IS_LSX)
 #endif
-#if SIMDUTF_IMPLEMENTATION_LSX && SIMDUTF_IS_LSX
-  #define SIMDUTF_CAN_ALWAYS_RUN_LSX 1
+#if SIMDUTF_IMPLEMENTATION_LASX && SIMDUTF_IS_LASX
+  #define SIMDUTF_CAN_ALWAYS_RUN_LASX 1
 #else
-  #define SIMDUTF_CAN_ALWAYS_RUN_LSX 0
+  #define SIMDUTF_CAN_ALWAYS_RUN_LASX 0
 #endif
 
 #define SIMDUTF_CAN_ALWAYS_RUN_FALLBACK (SIMDUTF_IMPLEMENTATION_FALLBACK)
 
-#if SIMDUTF_IMPLEMENTATION_LSX
+#if SIMDUTF_IMPLEMENTATION_LASX
+  #define SIMDUTF_TARGET_LASX SIMDUTF_TARGET_REGION("lasx,lsx")
+
+  // For runtime dispatching to work, we need the lsxintrin to appear
+  // before we call SIMDUTF_TARGET_LASX. It is unclear why.
+  #include <lsxintrin.h>
 
 namespace simdutf {
 /**
- * Implementation for LoongArch SX.
+ * Implementation for LoongArch ASX.
  */
-namespace lsx {} // namespace lsx
+namespace lasx {} // namespace lasx
 } // namespace simdutf
 
-/* begin file src/simdutf/lsx/implementation.h */
-#ifndef SIMDUTF_LSX_IMPLEMENTATION_H
-#define SIMDUTF_LSX_IMPLEMENTATION_H
+/* begin file src/simdutf/lasx/implementation.h */
+#ifndef SIMDUTF_LASX_IMPLEMENTATION_H
+#define SIMDUTF_LASX_IMPLEMENTATION_H
 
 
 namespace simdutf {
-namespace lsx {
+namespace lasx {
 
 namespace {
 using namespace simdutf;
@@ -8214,56 +7392,162 @@ using namespace simdutf;
 class implementation final : public simdutf::implementation {
 public:
   simdutf_really_inline implementation()
-      : simdutf::implementation("lsx", "LOONGARCH SX",
-                                internal::instruction_set::LSX) {}
+      : simdutf::implementation("lasx", "LOONGARCH ASX",
+                                internal::instruction_set::LSX |
+                                    internal::instruction_set::LASX) {}
 
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override;
 };
 
-} // namespace lsx
+} // namespace lasx
 } // namespace simdutf
 
-#endif // SIMDUTF_LSX_IMPLEMENTATION_H
-/* end file src/simdutf/lsx/implementation.h */
+#endif // SIMDUTF_LASX_IMPLEMENTATION_H
+/* end file src/simdutf/lasx/implementation.h */
 
-/* begin file src/simdutf/lsx/begin.h */
-// redefining SIMDUTF_IMPLEMENTATION to "lsx"
-// #define SIMDUTF_IMPLEMENTATION lsx
+/* begin file src/simdutf/lasx/begin.h */
+// redefining SIMDUTF_IMPLEMENTATION to "lasx"
+// #define SIMDUTF_IMPLEMENTATION lasx
 #define SIMDUTF_SIMD_HAS_UNSIGNED_CMP 1
-/* end file src/simdutf/lsx/begin.h */
+
+#if SIMDUTF_CAN_ALWAYS_RUN_LASX
+// nothing needed.
+#else
+SIMDUTF_TARGET_LASX
+#endif
+/* end file src/simdutf/lasx/begin.h */
 
   // Declarations
-/* begin file src/simdutf/lsx/intrinsics.h */
-#ifndef SIMDUTF_LSX_INTRINSICS_H
-#define SIMDUTF_LSX_INTRINSICS_H
+/* begin file src/simdutf/lasx/intrinsics.h */
+#ifndef SIMDUTF_LASX_INTRINSICS_H
+#define SIMDUTF_LASX_INTRINSICS_H
 
 
 // This should be the correct header whether
 // you use visual studio or other compilers.
 #include <lsxintrin.h>
+#include <lasxintrin.h>
+
+#if defined(__loongarch_asx)
+  #ifdef __clang__
+    #define VREGS_PREFIX "$vr"
+    #define XREGS_PREFIX "$xr"
+  #else // GCC
+    #define VREGS_PREFIX "$f"
+    #define XREGS_PREFIX "$f"
+  #endif
+  #define __ALL_REGS                                                           \
+    "0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,"  \
+    "27,28,29,30,31"
+// Convert __m128i to __m256i
+static inline __m256i ____m256i(__m128i in) {
+  __m256i out = __lasx_xvldi(0);
+  __asm__ volatile(".irp i," __ALL_REGS "\n\t"
+                   " .ifc %[out], " XREGS_PREFIX "\\i    \n\t"
+                   "  .irp j," __ALL_REGS "\n\t"
+                   "   .ifc %[in], " VREGS_PREFIX "\\j  \n\t"
+                   "    xvpermi.q $xr\\i, $xr\\j, 0x0  \n\t"
+                   "   .endif                           \n\t"
+                   "  .endr                             \n\t"
+                   " .endif                             \n\t"
+                   ".endr                               \n\t"
+                   : [out] "+f"(out)
+                   : [in] "f"(in));
+  return out;
+}
+// Convert two __m128i to __m256i
+static inline __m256i lasx_set_q(__m128i inhi, __m128i inlo) {
+  __m256i out;
+  __asm__ volatile(".irp i," __ALL_REGS "\n\t"
+                   " .ifc %[hi], " VREGS_PREFIX "\\i    \n\t"
+                   "  .irp j," __ALL_REGS "\n\t"
+                   "   .ifc %[lo], " VREGS_PREFIX "\\j  \n\t"
+                   "    xvpermi.q $xr\\i, $xr\\j, 0x20  \n\t"
+                   "   .endif                           \n\t"
+                   "  .endr                             \n\t"
+                   " .endif                             \n\t"
+                   ".endr                               \n\t"
+                   ".ifnc %[out], %[hi]                 \n\t"
+                   ".irp i," __ALL_REGS "\n\t"
+                   " .ifc %[out], " XREGS_PREFIX "\\i   \n\t"
+                   "  .irp j," __ALL_REGS "\n\t"
+                   "   .ifc %[hi], " VREGS_PREFIX "\\j  \n\t"
+                   "    xvori.b $xr\\i, $xr\\j, 0       \n\t"
+                   "   .endif                           \n\t"
+                   "  .endr                             \n\t"
+                   " .endif                             \n\t"
+                   ".endr                               \n\t"
+                   ".endif                              \n\t"
+                   : [out] "=f"(out), [hi] "+f"(inhi)
+                   : [lo] "f"(inlo));
+  return out;
+}
+// Convert __m256i low part to __m128i
+static inline __m128i lasx_extracti128_lo(__m256i in) {
+  __m128i out;
+  __asm__ volatile(".ifnc %[out], %[in]                 \n\t"
+                   ".irp i," __ALL_REGS "\n\t"
+                   " .ifc %[out], " VREGS_PREFIX "\\i   \n\t"
+                   "  .irp j," __ALL_REGS "\n\t"
+                   "   .ifc %[in], " XREGS_PREFIX "\\j  \n\t"
+                   "    vori.b $vr\\i, $vr\\j, 0        \n\t"
+                   "   .endif                           \n\t"
+                   "  .endr                             \n\t"
+                   " .endif                             \n\t"
+                   ".endr                               \n\t"
+                   ".endif                              \n\t"
+                   : [out] "=f"(out)
+                   : [in] "f"(in));
+  return out;
+}
+// Convert __m256i high part to __m128i
+static inline __m128i lasx_extracti128_hi(__m256i in) {
+  __m128i out;
+  __asm__ volatile(".irp i," __ALL_REGS "\n\t"
+                   " .ifc %[out], " VREGS_PREFIX "\\i   \n\t"
+                   "  .irp j," __ALL_REGS "\n\t"
+                   "   .ifc %[in], " XREGS_PREFIX "\\j  \n\t"
+                   "    xvpermi.q $xr\\i, $xr\\j, 0x11  \n\t"
+                   "   .endif                           \n\t"
+                   "  .endr                             \n\t"
+                   " .endif                             \n\t"
+                   ".endr                               \n\t"
+                   : [out] "=f"(out)
+                   : [in] "f"(in));
+  return out;
+}
+#endif
 
 /*
 Encoding of argument for LoongArch64 xvldi instruction.  See:
@@ -8293,7 +7577,7 @@ all lanes
 the result as 64-bit elements to all lanes
 */
 
-namespace vldi {
+namespace lasx_vldi {
 
 template <uint16_t v> class const_u16 {
   constexpr static const uint8_t b0 = ((v >> 0 * 8) & 0xff);
@@ -8410,7 +7694,8 @@ template <uint64_t v> class const_u64 {
   constexpr static int value = int((operation << 8) | byte) - 8192;
   constexpr static bool valid = operation != 0xffff;
 };
-} // namespace vldi
+
+} // namespace lasx_vldi
 
 // Uncomment when running under QEMU affected
 // by bug https://gitlab.com/qemu-project/qemu/-/issues/2865
@@ -8420,45 +7705,78 @@ template <uint64_t v> class const_u64 {
 #endif
 
 #ifdef QEMU_VLDI_BUG
-  #define lsx_splat_u16(v) __lsx_vreplgr2vr_h(v)
-  #define lsx_splat_u32(v) __lsx_vreplgr2vr_w(v)
+  #define lasx_splat_u16(v) __lasx_xvreplgr2vr_h(v)
+  #define lasx_splat_u32(v) __lasx_xvreplgr2vr_w(v)
 #else
-template <uint16_t x> constexpr __m128i lsx_splat_u16_aux() {
+template <uint16_t x> constexpr __m256i lasx_splat_u16_aux() {
   constexpr bool is_imm10 = (int16_t(x) < 512) && (int16_t(x) > -512);
   constexpr uint16_t imm10 = is_imm10 ? x : 0;
-  constexpr bool is_vldi = vldi::const_u16<x>::valid;
-  constexpr int vldi_imm = is_vldi ? vldi::const_u16<x>::value : 0;
+  constexpr bool is_vldi = lasx_vldi::const_u16<x>::valid;
+  constexpr int vldi_imm = is_vldi ? lasx_vldi::const_u16<x>::value : 0;
 
-  return is_imm10  ? __lsx_vrepli_h(int16_t(imm10))
-         : is_vldi ? __lsx_vldi(vldi_imm)
-                   : __lsx_vreplgr2vr_h(x);
+  return is_imm10  ? __lasx_xvrepli_h(int16_t(imm10))
+         : is_vldi ? __lasx_xvldi(vldi_imm)
+                   : __lasx_xvreplgr2vr_h(x);
 }
 
-template <uint32_t x> constexpr __m128i lsx_splat_u32_aux() {
+template <uint32_t x> constexpr __m256i lasx_splat_u32_aux() {
   constexpr bool is_imm10 = (int32_t(x) < 512) && (int32_t(x) > -512);
   constexpr uint32_t imm10 = is_imm10 ? x : 0;
-  constexpr bool is_vldi = vldi::const_u32<x>::valid;
-  constexpr int vldi_imm = is_vldi ? vldi::const_u32<x>::value : 0;
+  constexpr bool is_vldi = lasx_vldi::const_u32<x>::valid;
+  constexpr int vldi_imm = is_vldi ? lasx_vldi::const_u32<x>::value : 0;
 
-  return is_imm10  ? __lsx_vrepli_w(int32_t(imm10))
-         : is_vldi ? __lsx_vldi(vldi_imm)
-                   : __lsx_vreplgr2vr_w(x);
+  return is_imm10  ? __lasx_xvrepli_w(int32_t(imm10))
+         : is_vldi ? __lasx_xvldi(vldi_imm)
+                   : __lasx_xvreplgr2vr_w(x);
 }
 
-  #define lsx_splat_u16(v) lsx_splat_u16_aux<(v)>()
-  #define lsx_splat_u32(v) lsx_splat_u32_aux<(v)>()
+  #define lasx_splat_u16(v) lasx_splat_u16_aux<(v)>()
+  #define lasx_splat_u32(v) lasx_splat_u32_aux<(v)>()
 #endif // QEMU_VLDI_BUG
 
-#endif //  SIMDUTF_LSX_INTRINSICS_H
-/* end file src/simdutf/lsx/intrinsics.h */
-/* begin file src/simdutf/lsx/bitmanipulation.h */
-#ifndef SIMDUTF_LSX_BITMANIPULATION_H
-#define SIMDUTF_LSX_BITMANIPULATION_H
+#ifndef lsx_splat_u16
+  #ifdef QEMU_VLDI_BUG
+    #define lsx_splat_u16(v) __lsx_vreplgr2vr_h(v)
+    #define lsx_splat_u32(v) __lsx_vreplgr2vr_w(v)
+  #else
+namespace {
+template <uint16_t x> constexpr __m128i lsx_splat_u16_aux() {
+  return ((int16_t(x) < 512) && (int16_t(x) > -512))
+             ? __lsx_vrepli_h(
+                   ((int16_t(x) < 512) && (int16_t(x) > -512)) ? int16_t(x) : 0)
+             : (lasx_vldi::const_u16<x>::valid
+                    ? __lsx_vldi(lasx_vldi::const_u16<x>::valid
+                                     ? lasx_vldi::const_u16<x>::value
+                                     : 0)
+                    : __lsx_vreplgr2vr_h(x));
+}
+
+template <uint32_t x> constexpr __m128i lsx_splat_u32_aux() {
+  return ((int32_t(x) < 512) && (int32_t(x) > -512))
+             ? __lsx_vrepli_w(
+                   ((int32_t(x) < 512) && (int32_t(x) > -512)) ? int32_t(x) : 0)
+             : (lasx_vldi::const_u32<x>::valid
+                    ? __lsx_vldi(lasx_vldi::const_u32<x>::valid
+                                     ? lasx_vldi::const_u32<x>::value
+                                     : 0)
+                    : __lsx_vreplgr2vr_w(x));
+}
+} // namespace
+    #define lsx_splat_u16(v) lsx_splat_u16_aux<(v)>()
+    #define lsx_splat_u32(v) lsx_splat_u32_aux<(v)>()
+  #endif // QEMU_VLDI_BUG
+#endif   // lsx_splat_u16
+
+#endif //  SIMDUTF_LASX_INTRINSICS_H
+/* end file src/simdutf/lasx/intrinsics.h */
+/* begin file src/simdutf/lasx/bitmanipulation.h */
+#ifndef SIMDUTF_LASX_BITMANIPULATION_H
+#define SIMDUTF_LASX_BITMANIPULATION_H
 
 #include <limits>
 
 namespace simdutf {
-namespace lsx {
+namespace lasx {
 namespace {
 
 simdutf_really_inline int count_ones(uint64_t input_num) {
@@ -8472,171 +7790,349 @@ simdutf_really_inline int trailing_zeroes(uint64_t input_num) {
 #endif
 
 } // unnamed namespace
-} // namespace lsx
+} // namespace lasx
 } // namespace simdutf
 
-#endif // SIMDUTF_LSX_BITMANIPULATION_H
-/* end file src/simdutf/lsx/bitmanipulation.h */
-/* begin file src/simdutf/lsx/simd.h */
-#ifndef SIMDUTF_LSX_SIMD_H
-#define SIMDUTF_LSX_SIMD_H
+#endif // SIMDUTF_LASX_BITMANIPULATION_H
+/* end file src/simdutf/lasx/bitmanipulation.h */
+/* begin file src/simdutf/lasx/simd.h */
+#ifndef SIMDUTF_LASX_SIMD_H
+#define SIMDUTF_LASX_SIMD_H
 
 
 namespace simdutf {
-namespace lsx {
+namespace lasx {
 namespace {
 namespace simd {
 
-template <typename T> struct simd8;
+__attribute__((aligned(32))) static const uint8_t prev_shuf_table[32][32] = {
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+    {0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+     31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+    {0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+     30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13},
+    {0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+     29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
+    {0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+     28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
+    {0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+     27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
+    {0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+     26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+    {0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8,
+     25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7,
+     24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6,
+     23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5,
+     22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4,
+     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3,
+     20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2,
+     19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1,
+     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1},
+    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0},
+    {15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+     15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+     14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+     13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+     12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+     11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+     10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+     9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0},
+    {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+     8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0},
+    {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+     7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0},
+    {6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+     6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0},
+    {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+     5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0},
+    {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+     4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0},
+    {3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+     3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0},
+    {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+     2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0},
+    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0},
+    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+};
 
-//
-// Base class of simd8<uint8_t> and simd8<bool>, both of which use __m128i
-// internally.
-//
-template <typename T, typename Mask = simd8<bool>> struct base_u8 {
-  __m128i value;
-  static const int SIZE = sizeof(value);
+__attribute__((aligned(32))) static const uint8_t bitsel_mask_table[32][32] = {
+    {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0},
+    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0}};
 
-  // Conversion from/to SIMD register
-  simdutf_really_inline base_u8(const __m128i _value) : value(_value) {}
-  simdutf_really_inline operator const __m128i &() const { return this->value; }
-  simdutf_really_inline operator __m128i &() { return this->value; }
+// Forward-declared so they can be used by splat and friends.
+template <typename Child> struct base {
+  __m256i value;
+
+  // Zero constructor
+  simdutf_really_inline base() : value{__m256i()} {}
+
+  // Conversion from SIMD register
+  simdutf_really_inline base(const __m256i _value) : value(_value) {}
+  // Conversion to SIMD register
+  simdutf_really_inline operator const __m256i &() const { return this->value; }
+  simdutf_really_inline operator __m256i &() { return this->value; }
+  template <endianness big_endian>
+  simdutf_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
+    if (big_endian) {
+      __m256i zero = __lasx_xvldi(0);
+      __m256i in8 = __lasx_xvpermi_d(this->value, 0b11011000);
+      __m256i inlow = __lasx_xvilvl_b(in8, zero);
+      __m256i inhigh = __lasx_xvilvh_b(in8, zero);
+      __lasx_xvst(inlow, reinterpret_cast<uint16_t *>(ptr), 0);
+      __lasx_xvst(inhigh, reinterpret_cast<uint16_t *>(ptr), 32);
+    } else {
+      __m256i inlow = __lasx_vext2xv_hu_bu(this->value);
+      __m256i inhigh = __lasx_vext2xv_hu_bu(
+          __lasx_xvpermi_q(this->value, this->value, 0b00000001));
+      __lasx_xvst(inlow, reinterpret_cast<__m256i *>(ptr), 0);
+      __lasx_xvst(inhigh, reinterpret_cast<__m256i *>(ptr), 32);
+    }
+  }
+  simdutf_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
+    __m256i in32_0 = __lasx_vext2xv_wu_bu(this->value);
+    __lasx_xvst(in32_0, reinterpret_cast<uint32_t *>(ptr), 0);
 
+    __m256i in8_1 = __lasx_xvpermi_d(this->value, 0b00000001);
+    __m256i in32_1 = __lasx_vext2xv_wu_bu(in8_1);
+    __lasx_xvst(in32_1, reinterpret_cast<uint32_t *>(ptr), 32);
+
+    __m256i in8_2 = __lasx_xvpermi_d(this->value, 0b00000010);
+    __m256i in32_2 = __lasx_vext2xv_wu_bu(in8_2);
+    __lasx_xvst(in32_2, reinterpret_cast<uint32_t *>(ptr), 64);
+
+    __m256i in8_3 = __lasx_xvpermi_d(this->value, 0b00000011);
+    __m256i in32_3 = __lasx_vext2xv_wu_bu(in8_3);
+    __lasx_xvst(in32_3, reinterpret_cast<uint32_t *>(ptr), 96);
+  }
   // Bit operations
-  simdutf_really_inline simd8<T> operator|(const simd8<T> other) const {
-    return __lsx_vor_v(this->value, other);
+  simdutf_really_inline Child operator|(const Child other) const {
+    return __lasx_xvor_v(this->value, other);
   }
-  simdutf_really_inline simd8<T> operator&(const simd8<T> other) const {
-    return __lsx_vand_v(this->value, other);
+  simdutf_really_inline Child operator&(const Child other) const {
+    return __lasx_xvand_v(this->value, other);
   }
-  simdutf_really_inline simd8<T> operator^(const simd8<T> other) const {
-    return __lsx_vxor_v(this->value, other);
+  simdutf_really_inline Child operator^(const Child other) const {
+    return __lasx_xvxor_v(this->value, other);
   }
-  simdutf_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
-  simdutf_really_inline simd8<T> &operator|=(const simd8<T> other) {
-    auto this_cast = static_cast<simd8<T> *>(this);
+  simdutf_really_inline Child &operator|=(const Child other) {
+    auto this_cast = static_cast<Child *>(this);
     *this_cast = *this_cast | other;
     return *this_cast;
   }
+};
+
+template <typename T> struct simd8;
 
+template <typename T, typename Mask = simd8<bool>>
+struct base8 : base<simd8<T>> {
+  simdutf_really_inline base8() : base<simd8<T>>() {}
+  simdutf_really_inline base8(const __m256i _value) : base<simd8<T>>(_value) {}
   friend simdutf_really_inline Mask operator==(const simd8<T> lhs,
                                                const simd8<T> rhs) {
-    return __lsx_vseq_b(lhs, rhs);
+    return __lasx_xvseq_b(lhs, rhs);
   }
 
-  template <int N = 1>
+  static const int SIZE = sizeof(base<T>::value);
+
+  template <unsigned N = 1>
   simdutf_really_inline simd8<T> prev(const simd8<T> prev_chunk) const {
-    return __lsx_vor_v(__lsx_vbsll_v(this->value, N),
-                       __lsx_vbsrl_v(prev_chunk.value, 16 - N));
-  }
-};
+    static_assert(N <= 16, "unsupported shift value");
 
-// SIMD byte mask type (returned by things like eq and gt)
-template <> struct simd8<bool> : base_u8<bool> {
-  typedef uint16_t bitmask_t;
-  typedef uint32_t bitmask2_t;
+    if (!N)
+      return this->value;
 
-  static simdutf_really_inline simd8<bool> splat(bool _value) {
-    return __lsx_vreplgr2vr_b(uint8_t(-(!!_value)));
-  }
+    __m256i zero = __lasx_xvldi(0);
+    __m256i result, shuf;
+    if (N < 16) {
+      shuf = __lasx_xvld(prev_shuf_table[N], 0);
 
-  simdutf_really_inline simd8(const __m128i _value) : base_u8<bool>(_value) {}
-  // False constructor
-  simdutf_really_inline simd8() : simd8(__lsx_vldi(0)) {}
-  // Splat constructor
-  simdutf_really_inline simd8(bool _value) : simd8(splat(_value)) {}
-  simdutf_really_inline void store(uint8_t dst[16]) const {
-    return __lsx_vst(this->value, dst, 0);
-  }
+      result = __lasx_xvshuf_b(
+          __lasx_xvpermi_q(this->value, this->value, 0b00000001), this->value,
+          shuf);
+      __m256i srl_prev = __lasx_xvbsrl_v(
+          __lasx_xvpermi_q(zero, prev_chunk.value, 0b00110001), (16 - N));
+      __m256i mask = __lasx_xvld(bitsel_mask_table[N], 0);
+      result = __lasx_xvbitsel_v(result, srl_prev, mask);
 
-  simdutf_really_inline uint32_t to_bitmask() const {
-    return __lsx_vpickve2gr_wu(__lsx_vmsknz_b(*this), 0);
+      return result;
+    } else if (N == 16) {
+      return __lasx_xvpermi_q(this->value, prev_chunk.value, 0b00100001);
+    }
   }
 };
 
-// Unsigned bytes
-template <> struct simd8<uint8_t> : base_u8<uint8_t> {
-  static simdutf_really_inline simd8<uint8_t> splat(uint8_t _value) {
-    return __lsx_vreplgr2vr_b(_value);
-  }
-  static simdutf_really_inline simd8<uint8_t> zero() { return __lsx_vldi(0); }
-  static simdutf_really_inline simd8<uint8_t> load(const uint8_t *values) {
-    return __lsx_vld(values, 0);
-  }
-  simdutf_really_inline simd8(const __m128i _value)
-      : base_u8<uint8_t>(_value) {}
-  // Zero constructor
-  simdutf_really_inline simd8() : simd8(zero()) {}
-  // Array constructor
-  simdutf_really_inline simd8(const uint8_t values[16]) : simd8(load(values)) {}
-  // Splat constructor
-  simdutf_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
-  // Member-by-member initialization
-  simdutf_really_inline
-  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
-        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
-        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15)
-      : simd8((__m128i)v16u8{v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-                             v12, v13, v14, v15}) {}
-
-  // Repeat 16 values as many times as necessary (usually for lookup tables)
-  simdutf_really_inline static simd8<uint8_t>
-  repeat_16(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4,
-            uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9,
-            uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14,
-            uint8_t v15) {
-    return simd8<uint8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
-                          v13, v14, v15);
+// SIMD byte mask type (returned by things like eq and gt)
+template <> struct simd8<bool> : base8<bool> {
+  static simdutf_really_inline simd8<bool> splat(bool _value) {
+    return __lasx_xvreplgr2vr_b(uint8_t(-(!!_value)));
   }
 
-  // Store to array
-  simdutf_really_inline void store(uint8_t dst[16]) const {
-    return __lsx_vst(this->value, dst, 0);
-  }
+  simdutf_really_inline simd8() : base8() {}
+  simdutf_really_inline simd8(const __m256i _value) : base8<bool>(_value) {}
+  // Splat constructor
+  simdutf_really_inline simd8(bool _value) : base8<bool>(splat(_value)) {}
 
-  // Order-specific operations
-  simdutf_really_inline simd8<bool>
-  operator>=(const simd8<uint8_t> other) const {
-    return __lsx_vsle_bu(other, *this);
-  }
-  simdutf_really_inline simd8<bool>
-  operator>(const simd8<uint8_t> other) const {
-    return __lsx_vslt_bu(other, *this);
-  }
-  simdutf_really_inline simd8 &operator-=(const simd8<uint8_t> other) {
-    value = __lsx_vsub_b(value, other.value);
-    return *this;
+  simdutf_really_inline uint32_t to_bitmask() const {
+    __m256i mask = __lasx_xvmsknz_b(this->value);
+    uint32_t mask0 = __lasx_xvpickve2gr_wu(mask, 0);
+    uint32_t mask1 = __lasx_xvpickve2gr_wu(mask, 4);
+    return (mask0 | (mask1 << 16));
   }
-  // Same as >, but instead of guaranteeing all 1's == true, false = 0 and true
-  // = nonzero. For ARM, returns all 1's.
-  simdutf_really_inline simd8<uint8_t>
-  gt_bits(const simd8<uint8_t> other) const {
-    return simd8<uint8_t>(*this > other);
+  simdutf_really_inline bool any() const {
+    if (__lasx_xbz_b(this->value))
+      return false;
+    return true;
   }
+  simdutf_really_inline simd8<bool> operator~() const { return *this ^ true; }
+};
 
-  // Bit-specific operations
-  simdutf_really_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const {
-    return __lsx_vslt_bu(__lsx_vldi(0), __lsx_vand_v(this->value, bits));
-  }
-  simdutf_really_inline bool is_ascii() const {
-    return __lsx_vpickve2gr_hu(__lsx_vmskgez_b(this->value), 0) == 0xFFFF;
+template <typename T> struct base8_numeric : base8<T> {
+  static simdutf_really_inline simd8<T> splat(T _value) {
+    return __lasx_xvreplgr2vr_b(_value);
   }
-
-  simdutf_really_inline bool any_bits_set_anywhere() const {
-    return __lsx_vpickve2gr_hu(__lsx_vmsknz_b(this->value), 0) > 0;
+  static simdutf_really_inline simd8<T> zero() { return __lasx_xvldi(0); }
+  static simdutf_really_inline simd8<T> load(const T values[32]) {
+    return __lasx_xvld(reinterpret_cast<const __m256i *>(values), 0);
   }
-  template <int N> simdutf_really_inline simd8<uint8_t> shr() const {
-    return __lsx_vsrli_b(this->value, N);
+  // Repeat 16 values as many times as necessary (usually for lookup tables)
+  static simdutf_really_inline simd8<T> repeat_16(T v0, T v1, T v2, T v3, T v4,
+                                                  T v5, T v6, T v7, T v8, T v9,
+                                                  T v10, T v11, T v12, T v13,
+                                                  T v14, T v15) {
+    return simd8<T>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+                    v14, v15, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                    v12, v13, v14, v15);
   }
-  template <int N> simdutf_really_inline simd8<uint8_t> shl() const {
-    return __lsx_vslli_b(this->value, N);
+
+  simdutf_really_inline base8_numeric() : base8<T>() {}
+  simdutf_really_inline base8_numeric(const __m256i _value)
+      : base8<T>(_value) {}
+
+  // Store to array
+  simdutf_really_inline void store(T dst[32]) const {
+    return __lasx_xvst(this->value, reinterpret_cast<__m256i *>(dst), 0);
   }
 
+  // Override to distinguish from bool version
+  simdutf_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
+
   // Perform a lookup assuming the value is between 0 and 16 (undefined behavior
   // for out of range values)
   template <typename L>
   simdutf_really_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
-    return lookup_table.apply_lookup_16_to(*this);
+    __m256i origin = __lasx_xvand_v(this->value, __lasx_xvldi(0x1f));
+    return __lasx_xvshuf_b(__lasx_xvldi(0), lookup_table, origin);
   }
 
   template <typename L>
@@ -8650,150 +8146,119 @@ template <> struct simd8<uint8_t> : base_u8<uint8_t> {
         replace7, replace8, replace9, replace10, replace11, replace12,
         replace13, replace14, replace15));
   }
-
-  template <typename T>
-  simdutf_really_inline simd8<uint8_t>
-  apply_lookup_16_to(const simd8<T> original) const {
-    __m128i original_tmp = __lsx_vand_v(original, __lsx_vldi(0x1f));
-    return __lsx_vshuf_b(__lsx_vldi(0), *this, simd8<uint8_t>(original_tmp));
-  }
-
-  simdutf_really_inline uint64_t sum_bytes() const {
-    const auto sum_u16 = __lsx_vhaddw_hu_bu(value, value);
-    const auto sum_u32 = __lsx_vhaddw_wu_hu(sum_u16, sum_u16);
-    const auto sum_u64 = __lsx_vhaddw_du_wu(sum_u32, sum_u32);
-
-    return uint64_t(__lsx_vpickve2gr_du(sum_u64, 0)) +
-           uint64_t(__lsx_vpickve2gr_du(sum_u64, 1));
-  }
 };
 
 // Signed bytes
-template <> struct simd8<int8_t> {
-  __m128i value;
-
-  static const int SIZE = sizeof(value);
-
-  static simdutf_really_inline simd8<int8_t> splat(int8_t _value) {
-    return __lsx_vreplgr2vr_b(_value);
-  }
-  static simdutf_really_inline simd8<int8_t> zero() { return __lsx_vldi(0); }
-  static simdutf_really_inline simd8<int8_t> load(const int8_t values[16]) {
-    return __lsx_vld(values, 0);
-  }
+template <> struct simd8<int8_t> : base8_numeric<int8_t> {
+  simdutf_really_inline simd8() : base8_numeric<int8_t>() {}
+  simdutf_really_inline simd8(const __m256i _value)
+      : base8_numeric<int8_t>(_value) {}
 
-  template <endianness big_endian>
-  simdutf_really_inline void store_ascii_as_utf16(char16_t *p) const {
-    __m128i zero = __lsx_vldi(0);
-    if (match_system(big_endian)) {
-      __lsx_vst(__lsx_vilvl_b(zero, (__m128i)this->value),
-                reinterpret_cast<uint16_t *>(p), 0);
-      __lsx_vst(__lsx_vilvh_b(zero, (__m128i)this->value),
-                reinterpret_cast<uint16_t *>(p + 8), 0);
-    } else {
-      __lsx_vst(__lsx_vilvl_b((__m128i)this->value, zero),
-                reinterpret_cast<uint16_t *>(p), 0);
-      __lsx_vst(__lsx_vilvh_b((__m128i)this->value, zero),
-                reinterpret_cast<uint16_t *>(p + 8), 0);
-    }
+  // Splat constructor
+  simdutf_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
+  // Array constructor
+  simdutf_really_inline simd8(const int8_t values[32]) : simd8(load(values)) {}
+  simdutf_really_inline operator simd8<uint8_t>() const;
+  simdutf_really_inline bool is_ascii() const {
+    __m256i ascii_mask = __lasx_xvslti_b(this->value, 0);
+    if (__lasx_xbnz_v(ascii_mask))
+      return false;
+    return true;
   }
-
-  simdutf_really_inline void store_ascii_as_utf32(char32_t *p) const {
-    __m128i zero = __lsx_vldi(0);
-    __m128i in16low = __lsx_vilvl_b(zero, (__m128i)this->value);
-    __m128i in16high = __lsx_vilvh_b(zero, (__m128i)this->value);
-    __m128i in32_0 = __lsx_vilvl_h(zero, in16low);
-    __m128i in32_1 = __lsx_vilvh_h(zero, in16low);
-    __m128i in32_2 = __lsx_vilvl_h(zero, in16high);
-    __m128i in32_3 = __lsx_vilvh_h(zero, in16high);
-    __lsx_vst(in32_0, reinterpret_cast<uint32_t *>(p), 0);
-    __lsx_vst(in32_1, reinterpret_cast<uint32_t *>(p + 4), 0);
-    __lsx_vst(in32_2, reinterpret_cast<uint32_t *>(p + 8), 0);
-    __lsx_vst(in32_3, reinterpret_cast<uint32_t *>(p + 12), 0);
+  // Order-sensitive comparisons
+  simdutf_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
+    return __lasx_xvslt_b(other, this->value);
   }
-
-  // In places where the table can be reused, which is most uses in simdutf, it
-  // is worth it to do 4 table lookups, as there is no direct zero extension
-  // from u8 to u32.
-  simdutf_really_inline void store_ascii_as_utf32_tbl(char32_t *p) const {
-    const simd8<uint8_t> tb1{0, 255, 255, 255, 1, 255, 255, 255,
-                             2, 255, 255, 255, 3, 255, 255, 255};
-    const simd8<uint8_t> tb2{4, 255, 255, 255, 5, 255, 255, 255,
-                             6, 255, 255, 255, 7, 255, 255, 255};
-    const simd8<uint8_t> tb3{8,  255, 255, 255, 9,  255, 255, 255,
-                             10, 255, 255, 255, 11, 255, 255, 255};
-    const simd8<uint8_t> tb4{12, 255, 255, 255, 13, 255, 255, 255,
-                             14, 255, 255, 255, 15, 255, 255, 255};
-
-    // encourage store pairing and interleaving
-    const auto shuf1 = this->apply_lookup_16_to(tb1);
-    const auto shuf2 = this->apply_lookup_16_to(tb2);
-    shuf1.store(reinterpret_cast<int8_t *>(p));
-    shuf2.store(reinterpret_cast<int8_t *>(p + 4));
-
-    const auto shuf3 = this->apply_lookup_16_to(tb3);
-    const auto shuf4 = this->apply_lookup_16_to(tb4);
-    shuf3.store(reinterpret_cast<int8_t *>(p + 8));
-    shuf4.store(reinterpret_cast<int8_t *>(p + 12));
+  simdutf_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
+    return __lasx_xvslt_b(this->value, other);
   }
-  // Conversion from/to SIMD register
-  simdutf_really_inline simd8(const __m128i _value) : value(_value) {}
+};
 
-  // Zero constructor
-  simdutf_really_inline simd8() : simd8(zero()) {}
+// Unsigned bytes
+template <> struct simd8<uint8_t> : base8_numeric<uint8_t> {
+  simdutf_really_inline simd8() : base8_numeric<uint8_t>() {}
+  simdutf_really_inline simd8(const __m256i _value)
+      : base8_numeric<uint8_t>(_value) {}
   // Splat constructor
-  simdutf_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
+  simdutf_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
   // Array constructor
-  simdutf_really_inline simd8(const int8_t *values) : simd8(load(values)) {}
+  simdutf_really_inline simd8(const uint8_t values[32]) : simd8(load(values)) {}
+  // Member-by-member initialization
+  simdutf_really_inline
+  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
+        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
+        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15,
+        uint8_t v16, uint8_t v17, uint8_t v18, uint8_t v19, uint8_t v20,
+        uint8_t v21, uint8_t v22, uint8_t v23, uint8_t v24, uint8_t v25,
+        uint8_t v26, uint8_t v27, uint8_t v28, uint8_t v29, uint8_t v30,
+        uint8_t v31)
+      : simd8((__m256i)v32u8{v0,  v1,  v2,  v3,  v4,  v5,  v6,  v7,
+                             v8,  v9,  v10, v11, v12, v13, v14, v15,
+                             v16, v17, v18, v19, v20, v21, v22, v23,
+                             v24, v25, v26, v27, v28, v29, v30, v31}) {}
 
-  // Store to array
-  simdutf_really_inline void store(int8_t dst[16]) const {
-    return __lsx_vst(value, dst, 0);
+  // Saturated math
+  simdutf_really_inline simd8<uint8_t>
+  saturating_sub(const simd8<uint8_t> other) const {
+    return __lasx_xvssub_bu(this->value, other);
   }
 
-  simdutf_really_inline operator simd8<uint8_t>() const {
-    return ((__m128i)this->value);
+  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
+  simdutf_really_inline simd8<uint8_t>
+  gt_bits(const simd8<uint8_t> other) const {
+    return this->saturating_sub(other);
   }
-
-  simdutf_really_inline simd8<int8_t>
-  operator|(const simd8<int8_t> other) const {
-    return __lsx_vor_v((__m128i)value, (__m128i)other.value);
+  simdutf_really_inline simd8<bool>
+  operator>=(const simd8<uint8_t> other) const {
+    return __lasx_xvsle_bu(other, *this);
+  }
+  simdutf_really_inline simd8<bool>
+  operator>(const simd8<uint8_t> other) const {
+    return __lasx_xvslt_bu(other, *this);
+  }
+  simdutf_really_inline simd8 &operator-=(const simd8<uint8_t> other) {
+    value = __lasx_xvsub_b(value, other.value);
+    return *this;
   }
 
+  // Bit-specific operations
   simdutf_really_inline bool is_ascii() const {
-    return (__lsx_vpickve2gr_hu(__lsx_vmskgez_b((__m128i)this->value), 0) ==
-            0xffff);
+    __m256i ascii_mask = __lasx_xvslti_b(this->value, 0);
+    if (__lasx_xbnz_v(ascii_mask))
+      return false;
+    return true;
   }
-
-  // Order-sensitive comparisons
-  simdutf_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
-    return __lsx_vslt_b((__m128i)other.value, (__m128i)value);
+  simdutf_really_inline bool any_bits_set_anywhere() const {
+    if (__lasx_xbnz_v(this->value))
+      return true;
+    return false;
   }
-  simdutf_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
-    return __lsx_vslt_b((__m128i)value, (__m128i)other.value);
+  template <int N> simdutf_really_inline simd8<uint8_t> shr() const {
+    return __lasx_xvsrli_b(this->value, N);
   }
-
-  template <int N = 1>
-  simdutf_really_inline simd8<int8_t>
-  prev(const simd8<int8_t> prev_chunk) const {
-    return __lsx_vor_v(__lsx_vbsll_v(this->value, N),
-                       __lsx_vbsrl_v(prev_chunk.value, 16 - N));
+  template <int N> simdutf_really_inline simd8<uint8_t> shl() const {
+    return __lasx_xvslli_b(this->value, N);
   }
 
-  template <typename T>
-  simdutf_really_inline simd8<int8_t>
-  apply_lookup_16_to(const simd8<T> original) const {
-    __m128i original_tmp = __lsx_vand_v(original, __lsx_vldi(0x1f));
-    return __lsx_vshuf_b(__lsx_vldi(0), (__m128i)this->value,
-                         simd8<uint8_t>(original_tmp));
+  simdutf_really_inline uint64_t sum_bytes() const {
+    const auto sum_u16 = __lasx_xvhaddw_hu_bu(value, value);
+    const auto sum_u32 = __lasx_xvhaddw_wu_hu(sum_u16, sum_u16);
+    const auto sum_u64 = __lasx_xvhaddw_du_wu(sum_u32, sum_u32);
+
+    return uint64_t(__lasx_xvpickve2gr_du(sum_u64, 0)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 1)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 2)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 3));
   }
 };
+simdutf_really_inline simd8<int8_t>::operator simd8<uint8_t>() const {
+  return this->value;
+}
 
 template <typename T> struct simd8x64 {
   static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
-  static_assert(
-      NUM_CHUNKS == 4,
-      "LoongArch kernel should use four registers per 64-byte block.");
+  static_assert(NUM_CHUNKS == 2,
+                "LASX kernel should use two registers per 64-byte block.");
   simd8<T> chunks[NUM_CHUNKS];
 
   simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
@@ -8801,36 +8266,36 @@ template <typename T> struct simd8x64 {
   operator=(const simd8<T> other) = delete; // no assignment allowed
   simd8x64() = delete;                      // no default constructor allowed
 
-  simdutf_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1,
-                                 const simd8<T> chunk2, const simd8<T> chunk3)
-      : chunks{chunk0, chunk1, chunk2, chunk3} {}
+  simdutf_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1)
+      : chunks{chunk0, chunk1} {}
   simdutf_really_inline simd8x64(const T *ptr)
       : chunks{simd8<T>::load(ptr),
-               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T)),
-               simd8<T>::load(ptr + 2 * sizeof(simd8<T>) / sizeof(T)),
-               simd8<T>::load(ptr + 3 * sizeof(simd8<T>) / sizeof(T))} {}
+               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T))} {}
 
   simdutf_really_inline void store(T *ptr) const {
     this->chunks[0].store(ptr + sizeof(simd8<T>) * 0 / sizeof(T));
     this->chunks[1].store(ptr + sizeof(simd8<T>) * 1 / sizeof(T));
-    this->chunks[2].store(ptr + sizeof(simd8<T>) * 2 / sizeof(T));
-    this->chunks[3].store(ptr + sizeof(simd8<T>) * 3 / sizeof(T));
+  }
+
+  simdutf_really_inline uint64_t to_bitmask() const {
+    uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r_hi = this->chunks[1].to_bitmask();
+    return r_lo | (r_hi << 32);
   }
 
   simdutf_really_inline simd8x64<T> &operator|=(const simd8x64<T> &other) {
     this->chunks[0] |= other.chunks[0];
     this->chunks[1] |= other.chunks[1];
-    this->chunks[2] |= other.chunks[2];
-    this->chunks[3] |= other.chunks[3];
     return *this;
   }
 
   simdutf_really_inline simd8<T> reduce_or() const {
-    return (this->chunks[0] | this->chunks[1]) |
-           (this->chunks[2] | this->chunks[3]);
+    return this->chunks[0] | this->chunks[1];
   }
 
-  simdutf_really_inline bool is_ascii() const { return reduce_or().is_ascii(); }
+  simdutf_really_inline bool is_ascii() const {
+    return this->reduce_or().is_ascii();
+  }
 
   template <endianness endian>
   simdutf_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
@@ -8838,152 +8303,123 @@ template <typename T> struct simd8x64 {
                                                           sizeof(simd8<T>) * 0);
     this->chunks[1].template store_ascii_as_utf16<endian>(ptr +
                                                           sizeof(simd8<T>) * 1);
-    this->chunks[2].template store_ascii_as_utf16<endian>(ptr +
-                                                          sizeof(simd8<T>) * 2);
-    this->chunks[3].template store_ascii_as_utf16<endian>(ptr +
-                                                          sizeof(simd8<T>) * 3);
   }
 
   simdutf_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
-    this->chunks[0].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 0);
-    this->chunks[1].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 1);
-    this->chunks[2].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 2);
-    this->chunks[3].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 3);
+    this->chunks[0].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 0);
+    this->chunks[1].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 1);
   }
 
-  simdutf_really_inline uint64_t to_bitmask() const {
-    __m128i mask = __lsx_vbsll_v(__lsx_vmsknz_b(this->chunks[3]), 6);
-    mask = __lsx_vor_v(mask, __lsx_vbsll_v(__lsx_vmsknz_b(this->chunks[2]), 4));
-    mask = __lsx_vor_v(mask, __lsx_vbsll_v(__lsx_vmsknz_b(this->chunks[1]), 2));
-    mask = __lsx_vor_v(mask, __lsx_vmsknz_b(this->chunks[0]));
-    return __lsx_vpickve2gr_du(mask, 0);
+  simdutf_really_inline uint64_t lt(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask)
+        .to_bitmask();
   }
 
-  simdutf_really_inline uint64_t lt(const T m) const {
+  simdutf_really_inline uint64_t gteq(const T m) const {
     const simd8<T> mask = simd8<T>::splat(m);
-    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask,
-                          this->chunks[2] < mask, this->chunks[3] < mask)
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask)
         .to_bitmask();
   }
+
   simdutf_really_inline uint64_t gt(const T m) const {
     const simd8<T> mask = simd8<T>::splat(m);
-    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask,
-                          this->chunks[2] > mask, this->chunks[3] > mask)
+    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask)
         .to_bitmask();
   }
   simdutf_really_inline uint64_t gteq_unsigned(const uint8_t m) const {
     const simd8<uint8_t> mask = simd8<uint8_t>::splat(m);
-    return simd8x64<bool>(simd8<uint8_t>(this->chunks[0].value) >= mask,
-                          simd8<uint8_t>(this->chunks[1].value) >= mask,
-                          simd8<uint8_t>(this->chunks[2].value) >= mask,
-                          simd8<uint8_t>(this->chunks[3].value) >= mask)
+    return simd8x64<bool>((simd8<uint8_t>(__m256i(this->chunks[0])) >= mask),
+                          (simd8<uint8_t>(__m256i(this->chunks[1])) >= mask))
         .to_bitmask();
   }
 }; // struct simd8x64<T>
 
-/* begin file src/simdutf/lsx/simd16-inl.h */
+/* begin file src/simdutf/lasx/simd16-inl.h */
 template <typename T> struct simd16;
 
-template <typename T, typename Mask = simd16<bool>> struct base_u16 {
-  __m128i value;
-  static const size_t SIZE = sizeof(value);
-  static const size_t ELEMENTS = sizeof(value) / sizeof(T);
-
-  // Conversion from/to SIMD register
-  simdutf_really_inline base_u16() = default;
-  simdutf_really_inline base_u16(const __m128i _value) : value(_value) {}
-  // Bit operations
-  simdutf_really_inline simd16<T> operator|(const simd16<T> other) const {
-    return __lsx_vor_v(this->value, other.value);
-  }
-  simdutf_really_inline simd16<T> operator&(const simd16<T> other) const {
-    return __lsx_vand_v(this->value, other.value);
-  }
-  simdutf_really_inline simd16<T> operator~() const {
-    return __lsx_vxori_b(this->value, 0xFF);
-  }
-
-  friend simdutf_really_inline Mask operator==(const simd16<T> lhs,
-                                               const simd16<T> rhs) {
-    return __lsx_vseq_h(lhs.value, rhs.value);
-  }
-
-  template <unsigned N>
-  simdutf_really_inline simd16<T> byte_right_shift() const {
-    return __lsx_vbsrl_v(this->value, N);
-  }
-
-  simdutf_really_inline uint16_t first() const {
-    return uint16_t(__lsx_vpickve2gr_w(value, 0));
-  }
-};
-
 template <typename T, typename Mask = simd16<bool>>
-struct base16 : base_u16<T> {
-  using bitmask_type = uint16_t;
+struct base16 : base<simd16<T>> {
+  using bitmask_type = uint32_t;
 
-  simdutf_really_inline base16() : base_u16<T>() {}
-  simdutf_really_inline base16(const __m128i _value) : base_u16<T>(_value) {}
+  simdutf_really_inline base16() : base<simd16<T>>() {}
+  simdutf_really_inline base16(const __m256i _value)
+      : base<simd16<T>>(_value) {}
   template <typename Pointer>
   simdutf_really_inline base16(const Pointer *ptr)
-      : base16(__lsx_vld(ptr, 0)) {}
+      : base16(__lasx_xvld(reinterpret_cast<const __m256i *>(ptr), 0)) {}
 
-  static const int SIZE = sizeof(base_u16<T>::value);
+  /// the size of vector in bytes
+  static const int SIZE = sizeof(base<simd16<T>>::value);
 
-  template <unsigned N = 1>
-  simdutf_really_inline simd16<T> prev(const simd16<T> prev_chunk) const {
-    return __lsx_vor_v(__lsx_vbsll_v(*this, N * 2),
-                       __lsx_vbsrl_v(prev_chunk, 16 - N * 2));
-  }
+  /// the number of elements of type T a vector can hold
+  static const int ELEMENTS = SIZE / sizeof(T);
 };
 
 // SIMD byte mask type (returned by things like eq and gt)
 template <> struct simd16<bool> : base16<bool> {
   static simdutf_really_inline simd16<bool> splat(bool _value) {
-    return __lsx_vreplgr2vr_h(uint16_t(-(!!_value)));
+    return __lasx_xvreplgr2vr_h(uint16_t(-(!!_value)));
   }
 
   simdutf_really_inline simd16() : base16() {}
-  simdutf_really_inline simd16(const __m128i _value) : base16<bool>(_value) {}
+  simdutf_really_inline simd16(const __m256i _value) : base16<bool>(_value) {}
+  // Splat constructor
+  simdutf_really_inline simd16(bool _value) : base16<bool>(splat(_value)) {}
 
   simdutf_really_inline bitmask_type to_bitmask() const {
-    __m128i mask = __lsx_vmsknz_b(this->value);
-    bitmask_type mask0 = bitmask_type(__lsx_vpickve2gr_wu(mask, 0));
-    return mask0;
+    __m256i mask = __lasx_xvmsknz_b(this->value);
+    bitmask_type mask0 = __lasx_xvpickve2gr_wu(mask, 0);
+    bitmask_type mask1 = __lasx_xvpickve2gr_wu(mask, 4);
+    return (mask0 | (mask1 << 16));
   }
+  simdutf_really_inline simd16<bool> operator~() const { return *this ^ true; }
 
-  simdutf_really_inline bool is_zero() const { return __lsx_bz_v(this->value); }
+  simdutf_really_inline bool is_zero() const {
+    return __lasx_xbz_v(this->value);
+  }
+
+  template <unsigned N> simdutf_really_inline simd16 byte_right_shift() const {
+    const auto t0 = __lasx_xvbsrl_v(this->value, N);
+    const auto t1 = __lasx_xvpermi_q(this->value, __lasx_xvldi(0), 0b00000011);
+    const auto t2 = __lasx_xvbsll_v(t1, 16 - N);
+    const auto t3 = __lasx_xvor_v(t0, t2);
+    return t3;
+  }
+
+  simdutf_really_inline uint16_t first() const {
+    return uint16_t(__lasx_xvpickve2gr_w(value, 0));
+  }
 };
 
 template <typename T> struct base16_numeric : base16<T> {
   static simdutf_really_inline simd16<T> splat(T _value) {
-    return __lsx_vreplgr2vr_h(_value);
+    return __lasx_xvreplgr2vr_h((uint16_t)_value);
   }
-  static simdutf_really_inline simd16<T> zero() { return __lsx_vldi(0); }
-
+  static simdutf_really_inline simd16<T> zero() { return __lasx_xvldi(0); }
   template <typename Pointer>
   static simdutf_really_inline simd16<T> load(const Pointer values) {
-    return __lsx_vld(values, 0);
+    return __lasx_xvld(values, 0);
   }
 
-  simdutf_really_inline base16_numeric(const __m128i _value)
+  simdutf_really_inline base16_numeric() : base16<T>() {}
+  simdutf_really_inline base16_numeric(const __m256i _value)
       : base16<T>(_value) {}
 
   // Store to array
   simdutf_really_inline void store(T dst[8]) const {
-    return __lsx_vst(this->value, dst, 0);
+    return __lasx_xvst(this->value, reinterpret_cast<__m256i *>(dst), 0);
   }
 
   // Override to distinguish from bool version
-  simdutf_really_inline simd16<T> operator~() const {
-    return __lsx_vxori_b(this->value, 0xFF);
-  }
+  simdutf_really_inline simd16<T> operator~() const { return *this ^ 0xFFFFu; }
 };
 
-// Unsigned code unitstemplate<>
+// Unsigned code units
 template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
-  simdutf_really_inline simd16(const __m128i _value)
-      : base16_numeric<uint16_t>((__m128i)_value) {}
+  simdutf_really_inline simd16() : base16_numeric<uint16_t>() {}
+  simdutf_really_inline simd16(const __m256i _value)
+      : base16_numeric<uint16_t>(_value) {}
 
   // Splat constructor
   simdutf_really_inline simd16(uint16_t _value) : simd16(splat(_value)) {}
@@ -8993,67 +8429,71 @@ template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
   simdutf_really_inline simd16(const char16_t *values)
       : simd16(load(reinterpret_cast<const uint16_t *>(values))) {}
 
-  // Copy constructor
-  simdutf_really_inline simd16(const simd16<bool> mask) : simd16(mask.value) {}
-
   // Order-specific operations
   simdutf_really_inline simd16 &operator+=(const simd16 other) {
-    value = __lsx_vadd_h(value, other.value);
+    value = __lasx_xvadd_h(value, other.value);
     return *this;
   }
 
+  // Change the endianness
+  simdutf_really_inline simd16<uint16_t> swap_bytes() const {
+    return __lasx_xvshuf4i_b(this->value, 0b10110001);
+  }
+
   template <unsigned N>
   static simdutf_really_inline simd8<uint8_t>
   pack_shifted_right(const simd16<uint16_t> &v0, const simd16<uint16_t> &v1) {
-    return __lsx_vssrlni_bu_h(v1.value, v0.value, N);
+    return __lasx_xvpermi_d(__lasx_xvssrlni_bu_h(v1.value, v0.value, N),
+                            0b11011000);
   }
 
   // Pack with the unsigned saturation of two uint16_t code units into single
   // uint8_t vector
   static simdutf_really_inline simd8<uint8_t> pack(const simd16<uint16_t> &v0,
                                                    const simd16<uint16_t> &v1) {
-    return pack_shifted_right<0>(v0, v1);
-  }
 
-  // Change the endianness
-  simdutf_really_inline simd16<uint16_t> swap_bytes() const {
-    return __lsx_vshuf4i_b(this->value, 0b10110001);
+    return pack_shifted_right<0>(v0, v1);
   }
 
   simdutf_really_inline uint64_t sum() const {
-    const auto sum_u32 = __lsx_vhaddw_wu_hu(value, value);
-    const auto sum_u64 = __lsx_vhaddw_du_wu(sum_u32, sum_u32);
+    const auto sum_u32 = __lasx_xvhaddw_wu_hu(value, value);
+    const auto sum_u64 = __lasx_xvhaddw_du_wu(sum_u32, sum_u32);
 
-    return uint64_t(__lsx_vpickve2gr_du(sum_u64, 0)) +
-           uint64_t(__lsx_vpickve2gr_du(sum_u64, 1));
+    return uint64_t(__lasx_xvpickve2gr_du(sum_u64, 0)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 1)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 2)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 3));
+  }
+
+  template <unsigned N> simdutf_really_inline simd16 byte_right_shift() const {
+    return __lasx_xvbsrl_v(this->value, N);
   }
 };
 
 simdutf_really_inline simd16<bool> operator<(const simd16<uint16_t> a,
                                              const simd16<uint16_t> b) {
-  return __lsx_vslt_hu(a.value, b.value);
+  return __lasx_xvslt_hu(a.value, b.value);
 }
 
 simdutf_really_inline simd16<bool> operator>(const simd16<uint16_t> a,
                                              const simd16<uint16_t> b) {
-  return __lsx_vslt_hu(b.value, a.value);
+  return __lasx_xvslt_hu(b.value, a.value);
 }
 
 simdutf_really_inline simd16<bool> operator<=(const simd16<uint16_t> a,
                                               const simd16<uint16_t> b) {
-  return __lsx_vsle_hu(a.value, b.value);
+  return __lasx_xvsle_hu(a.value, b.value);
 }
 
 simdutf_really_inline simd16<bool> operator>=(const simd16<uint16_t> a,
                                               const simd16<uint16_t> b) {
-  return __lsx_vsle_hu(b.value, a.value);
+  return __lasx_xvsle_hu(b.value, a.value);
 }
 
 template <typename T> struct simd16x32 {
   static constexpr int NUM_CHUNKS = 64 / sizeof(simd16<T>);
-  static_assert(
-      NUM_CHUNKS == 4,
-      "LOONGARCH kernel should use four registers per 64-byte block.");
+  static_assert(NUM_CHUNKS == 2,
+                "LASX kernel should use two registers per 64-byte block.");
   simd16<T> chunks[NUM_CHUNKS];
 
   simd16x32(const simd16x32<T> &o) = delete; // no copy allowed
@@ -9061,127 +8501,144 @@ template <typename T> struct simd16x32 {
   operator=(const simd16<T> other) = delete; // no assignment allowed
   simd16x32() = delete;                      // no default constructor allowed
 
-  simdutf_really_inline
-  simd16x32(const simd16<T> chunk0, const simd16<T> chunk1,
-            const simd16<T> chunk2, const simd16<T> chunk3)
-      : chunks{chunk0, chunk1, chunk2, chunk3} {}
+  simdutf_really_inline simd16x32(const simd16<T> chunk0,
+                                  const simd16<T> chunk1)
+      : chunks{chunk0, chunk1} {}
   simdutf_really_inline simd16x32(const T *ptr)
       : chunks{simd16<T>::load(ptr),
-               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T)),
-               simd16<T>::load(ptr + 2 * sizeof(simd16<T>) / sizeof(T)),
-               simd16<T>::load(ptr + 3 * sizeof(simd16<T>) / sizeof(T))} {}
+               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T))} {}
 
   simdutf_really_inline void store(T *ptr) const {
     this->chunks[0].store(ptr + sizeof(simd16<T>) * 0 / sizeof(T));
     this->chunks[1].store(ptr + sizeof(simd16<T>) * 1 / sizeof(T));
-    this->chunks[2].store(ptr + sizeof(simd16<T>) * 2 / sizeof(T));
-    this->chunks[3].store(ptr + sizeof(simd16<T>) * 3 / sizeof(T));
   }
 
   simdutf_really_inline void swap_bytes() {
     this->chunks[0] = this->chunks[0].swap_bytes();
     this->chunks[1] = this->chunks[1].swap_bytes();
-    this->chunks[2] = this->chunks[2].swap_bytes();
-    this->chunks[3] = this->chunks[3].swap_bytes();
   }
   simdutf_really_inline uint64_t to_bitmask() const {
-    uint64_t r0 = uint32_t(this->chunks[0].to_bitmask());
-    uint64_t r1 = this->chunks[1].to_bitmask();
-    uint64_t r2 = this->chunks[2].to_bitmask();
-    uint64_t r3 = this->chunks[3].to_bitmask();
-    return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);
+    uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r_hi = this->chunks[1].to_bitmask();
+    return r_lo | (r_hi << 32);
+  }
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask)
+        .to_bitmask();
   }
   simdutf_really_inline uint64_t lteq(const T m) const {
     const simd16<T> mask = simd16<T>::splat(m);
-    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
-                           this->chunks[2] <= mask, this->chunks[3] <= mask)
+    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask)
         .to_bitmask();
   }
 }; // struct simd16x32<T>
 
-simdutf_really_inline simd16<uint16_t> operator^(const simd16<uint16_t> a,
+simdutf_really_inline simd16<uint16_t> min(const simd16<uint16_t> a,
+                                           const simd16<uint16_t> b) {
+  return __lasx_xvmin_hu(a.value, b.value);
+}
+
+simdutf_really_inline simd16<bool> operator==(const simd16<uint16_t> a,
+                                              uint16_t b) {
+  const auto bv = __lasx_xvreplgr2vr_h(b);
+  return __lasx_xvseq_h(a.value, bv);
+}
+
+simdutf_really_inline simd16<uint16_t> as_vector_u16(const simd16<bool> x) {
+  return x.value;
+}
+
+simdutf_really_inline simd16<uint16_t> operator&(const simd16<uint16_t> a,
                                                  uint16_t b) {
-  const auto bv = __lsx_vreplgr2vr_h(b);
-  return __lsx_vxor_v(a.value, bv);
+  const auto bv = __lasx_xvreplgr2vr_h(b);
+  return __lasx_xvand_v(a.value, bv);
 }
 
-simdutf_really_inline simd16<bool> operator^(const simd16<bool> a,
-                                             const simd16<bool> b) {
-  return __lsx_vxor_v(a.value, b.value);
+simdutf_really_inline simd16<uint16_t> operator&(const simd16<uint16_t> a,
+                                                 const simd16<uint16_t> b) {
+  return __lasx_xvand_v(a.value, b.value);
 }
 
-simdutf_really_inline simd16<uint16_t> min(const simd16<uint16_t> a,
-                                           const simd16<uint16_t> b) {
-  return __lsx_vmin_hu(a.value, b.value);
+simdutf_really_inline simd16<uint16_t> operator^(const simd16<uint16_t> a,
+                                                 uint16_t b) {
+  const auto bv = __lasx_xvreplgr2vr_h(b);
+  return __lasx_xvxor_v(a.value, bv);
 }
 
-simdutf_really_inline simd16<uint16_t> as_vector_u16(const simd16<bool> x) {
-  return x.value;
+simdutf_really_inline simd16<bool> operator^(const simd16<bool> a,
+                                             const simd16<bool> b) {
+  return __lasx_xvxor_v(a.value, b.value);
 }
-/* end file src/simdutf/lsx/simd16-inl.h */
-/* begin file src/simdutf/lsx/simd32-inl.h */
+/* end file src/simdutf/lasx/simd16-inl.h */
+/* begin file src/simdutf/lasx/simd32-inl.h */
 template <typename T> struct simd32;
 
 template <> struct simd32<uint32_t> {
-  __m128i value;
+  __m256i value;
   static const int SIZE = sizeof(value);
   static const int ELEMENTS = SIZE / sizeof(uint32_t);
 
   // constructors
-  simdutf_really_inline simd32(__m128i v) : value(v) {}
+  simdutf_really_inline simd32(__m256i v) : value(v) {}
 
   template <typename Ptr>
-  simdutf_really_inline simd32(Ptr *ptr) : value(__lsx_vld(ptr, 0)) {}
+  simdutf_really_inline simd32(Ptr *ptr) : value(__lasx_xvld(ptr, 0)) {}
 
   // in-place operators
   simdutf_really_inline simd32 &operator-=(const simd32 other) {
-    value = __lsx_vsub_w(value, other.value);
+    value = __lasx_xvsub_w(value, other.value);
     return *this;
   }
 
   // members
   simdutf_really_inline uint64_t sum() const {
-    return uint64_t(__lsx_vpickve2gr_wu(value, 0)) +
-           uint64_t(__lsx_vpickve2gr_wu(value, 1)) +
-           uint64_t(__lsx_vpickve2gr_wu(value, 2)) +
-           uint64_t(__lsx_vpickve2gr_wu(value, 3));
+    const auto odd = __lasx_xvsrli_d(value, 32);
+    const auto even = __lasx_xvand_v(value, __lasx_xvreplgr2vr_d(0xffffffff));
+
+    const auto sum64 = __lasx_xvadd_d(odd, even);
+
+    return uint64_t(__lasx_xvpickve2gr_du(sum64, 0)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum64, 1)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum64, 2)) +
+           uint64_t(__lasx_xvpickve2gr_du(sum64, 3));
   }
 
   // static members
   static simdutf_really_inline simd32<uint32_t> splat(uint32_t x) {
-    return __lsx_vreplgr2vr_w(x);
+    return __lasx_xvreplgr2vr_w(x);
   }
 
   static simdutf_really_inline simd32<uint32_t> zero() {
-    return __lsx_vrepli_w(0);
+    return __lasx_xvrepli_w(0);
   }
 };
 
 // ------------------------------------------------------------
 
 template <> struct simd32<bool> {
-  __m128i value;
+  __m256i value;
   static const int SIZE = sizeof(value);
 
   // constructors
-  simdutf_really_inline simd32(__m128i v) : value(v) {}
+  simdutf_really_inline simd32(__m256i v) : value(v) {}
 };
 
 // ------------------------------------------------------------
 
 simdutf_really_inline simd32<uint32_t> operator&(const simd32<uint32_t> a,
                                                  const simd32<uint32_t> b) {
-  return __lsx_vor_v(a.value, b.value);
+  return __lasx_xvor_v(a.value, b.value);
 }
 
 simdutf_really_inline simd32<bool> operator<(const simd32<uint32_t> a,
                                              const simd32<uint32_t> b) {
-  return __lsx_vslt_wu(a.value, b.value);
+  return __lasx_xvslt_wu(a.value, b.value);
 }
 
 simdutf_really_inline simd32<bool> operator>(const simd32<uint32_t> a,
                                              const simd32<uint32_t> b) {
-  return __lsx_vslt_wu(b.value, a.value);
+  return __lasx_xvslt_wu(b.value, a.value);
 }
 
 // ------------------------------------------------------------
@@ -9189,112 +8646,128 @@ simdutf_really_inline simd32<bool> operator>(const simd32<uint32_t> a,
 simdutf_really_inline simd32<uint32_t> as_vector_u32(const simd32<bool> v) {
   return v.value;
 }
-/* end file src/simdutf/lsx/simd32-inl.h */
-/* begin file src/simdutf/lsx/simd64-inl.h */
+/* end file src/simdutf/lasx/simd32-inl.h */
+/* begin file src/simdutf/lasx/simd64-inl.h */
 template <typename T> struct simd64;
 
 template <> struct simd64<uint64_t> {
-  __m128i value;
+  __m256i value;
   static const int SIZE = sizeof(value);
   static const int ELEMENTS = SIZE / sizeof(uint64_t);
 
   // constructors
-  simdutf_really_inline simd64(__m128i v) : value(v) {}
+  simdutf_really_inline simd64(__m256i v) : value(v) {}
 
   template <typename Ptr>
-  simdutf_really_inline simd64(Ptr *ptr) : value(__lsx_vld(ptr, 0)) {}
+  simdutf_really_inline simd64(Ptr *ptr) : value(__lasx_xvld(ptr, 0)) {}
 
   // in-place operators
   simdutf_really_inline simd64 &operator+=(const simd64 other) {
-    value = __lsx_vadd_d(value, other.value);
+    value = __lasx_xvadd_d(value, other.value);
     return *this;
   }
 
   // members
   simdutf_really_inline uint64_t sum() const {
-    return uint64_t(__lsx_vpickve2gr_du(value, 0)) +
-           uint64_t(__lsx_vpickve2gr_du(value, 1));
+    return uint64_t(__lasx_xvpickve2gr_du(value, 0)) +
+           uint64_t(__lasx_xvpickve2gr_du(value, 1)) +
+           uint64_t(__lasx_xvpickve2gr_du(value, 2)) +
+           uint64_t(__lasx_xvpickve2gr_du(value, 3));
   }
 
   // static members
   static simdutf_really_inline simd64<uint64_t> zero() {
-    return __lsx_vrepli_d(0);
+    return __lasx_xvrepli_d(0);
   }
 };
 
 // ------------------------------------------------------------
 
 template <> struct simd64<bool> {
-  __m128i value;
+  __m256i value;
   static const int SIZE = sizeof(value);
 
   // constructors
-  simdutf_really_inline simd64(__m128i v) : value(v) {}
+  simdutf_really_inline simd64(__m256i v) : value(v) {}
 };
 
 // ------------------------------------------------------------
 
 simd64<uint64_t> sum_8bytes(const simd8<uint8_t> v) {
-  const auto sum_u16 = __lsx_vhaddw_hu_bu(v, v);
-  const auto sum_u32 = __lsx_vhaddw_wu_hu(sum_u16, sum_u16);
-  const auto sum_u64 = __lsx_vhaddw_du_wu(sum_u32, sum_u32);
+  const auto sum_u16 = __lasx_xvhaddw_hu_bu(v, v);
+  const auto sum_u32 = __lasx_xvhaddw_wu_hu(sum_u16, sum_u16);
+  const auto sum_u64 = __lasx_xvhaddw_du_wu(sum_u32, sum_u32);
 
   return simd64<uint64_t>(sum_u64);
 }
-/* end file src/simdutf/lsx/simd64-inl.h */
+/* end file src/simdutf/lasx/simd64-inl.h */
 
 } // namespace simd
 } // unnamed namespace
-} // namespace lsx
+} // namespace lasx
 } // namespace simdutf
 
-#endif // SIMDUTF_LSX_SIMD_H
-/* end file src/simdutf/lsx/simd.h */
+#endif // SIMDUTF_LASX_SIMD_H
+/* end file src/simdutf/lasx/simd.h */
 
-/* begin file src/simdutf/lsx/end.h */
+/* begin file src/simdutf/lasx/end.h */
 #undef SIMDUTF_SIMD_HAS_UNSIGNED_CMP
-/* end file src/simdutf/lsx/end.h */
 
-#endif // SIMDUTF_IMPLEMENTATION_LSX
+#if SIMDUTF_CAN_ALWAYS_RUN_LASX
+// nothing needed.
+#else
+SIMDUTF_UNTARGET_REGION
+#endif
+/* end file src/simdutf/lasx/end.h */
 
-#endif // SIMDUTF_LSX_H
-/* end file src/simdutf/lsx.h */
-/* begin file src/simdutf/lasx.h */
-#ifndef SIMDUTF_LASX_H
-#define SIMDUTF_LASX_H
+#endif // SIMDUTF_IMPLEMENTATION_LASX
+
+#endif // SIMDUTF_LASX_H
+/* end file src/simdutf/lasx.h */
+/* begin file src/simdutf/lsx.h */
+#ifndef SIMDUTF_LSX_H
+#define SIMDUTF_LSX_H
 
 #ifdef SIMDUTF_FALLBACK_H
-  #error "lasx.h must be included before fallback.h"
+  #error "lsx.h must be included before fallback.h"
+#endif
+
+#ifndef SIMDUTF_CAN_ALWAYS_RUN_LASX
+  #error "lsx.h must be included after lasx.h"
 #endif
 
 
-#ifndef SIMDUTF_IMPLEMENTATION_LASX
-  #define SIMDUTF_IMPLEMENTATION_LASX (SIMDUTF_IS_LASX)
+#ifndef SIMDUTF_IMPLEMENTATION_LSX
+  #if SIMDUTF_CAN_ALWAYS_RUN_LASX
+    #define SIMDUTF_IMPLEMENTATION_LSX 0
+  #else
+    #define SIMDUTF_IMPLEMENTATION_LSX (SIMDUTF_IS_LSX)
+  #endif
 #endif
-#if SIMDUTF_IMPLEMENTATION_LASX && SIMDUTF_IS_LASX
-  #define SIMDUTF_CAN_ALWAYS_RUN_LASX 1
+#if SIMDUTF_IMPLEMENTATION_LSX && SIMDUTF_IS_LSX
+  #define SIMDUTF_CAN_ALWAYS_RUN_LSX 1
 #else
-  #define SIMDUTF_CAN_ALWAYS_RUN_LASX 0
+  #define SIMDUTF_CAN_ALWAYS_RUN_LSX 0
 #endif
 
 #define SIMDUTF_CAN_ALWAYS_RUN_FALLBACK (SIMDUTF_IMPLEMENTATION_FALLBACK)
 
-#if SIMDUTF_IMPLEMENTATION_LASX
+#if SIMDUTF_IMPLEMENTATION_LSX
 
 namespace simdutf {
 /**
- * Implementation for LoongArch ASX.
+ * Implementation for LoongArch SX.
  */
-namespace lasx {} // namespace lasx
+namespace lsx {} // namespace lsx
 } // namespace simdutf
 
-/* begin file src/simdutf/lasx/implementation.h */
-#ifndef SIMDUTF_LASX_IMPLEMENTATION_H
-#define SIMDUTF_LASX_IMPLEMENTATION_H
+/* begin file src/simdutf/lsx/implementation.h */
+#ifndef SIMDUTF_LSX_IMPLEMENTATION_H
+#define SIMDUTF_LSX_IMPLEMENTATION_H
 
 
 namespace simdutf {
-namespace lasx {
+namespace lsx {
 
 namespace {
 using namespace simdutf;
@@ -9303,148 +8776,64 @@ using namespace simdutf;
 class implementation final : public simdutf::implementation {
 public:
   simdutf_really_inline implementation()
-      : simdutf::implementation("lasx", "LOONGARCH ASX",
-                                internal::instruction_set::LSX |
-                                    internal::instruction_set::LASX) {}
+      : simdutf::implementation("lsx", "LOONGARCH SX",
+                                internal::instruction_set::LSX) {}
 
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char16_t *input, size_t length, char *output,
       base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
   const char *find(const char *start, const char *end,
-                   char character) const noexcept;
+                   char character) const noexcept override;
   const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
+                       char16_t character) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override;
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override;
 };
 
-} // namespace lasx
+} // namespace lsx
 } // namespace simdutf
 
-#endif // SIMDUTF_LASX_IMPLEMENTATION_H
-/* end file src/simdutf/lasx/implementation.h */
-
-/* begin file src/simdutf/lasx/begin.h */
-// redefining SIMDUTF_IMPLEMENTATION to "lasx"
-// #define SIMDUTF_IMPLEMENTATION lasx
-#define SIMDUTF_SIMD_HAS_UNSIGNED_CMP 1
-/* end file src/simdutf/lasx/begin.h */
-
-  // Declarations
-/* begin file src/simdutf/lasx/intrinsics.h */
-#ifndef SIMDUTF_LASX_INTRINSICS_H
-#define SIMDUTF_LASX_INTRINSICS_H
-
-
-// This should be the correct header whether
-// you use visual studio or other compilers.
-#include <lsxintrin.h>
-#include <lasxintrin.h>
+#endif // SIMDUTF_LSX_IMPLEMENTATION_H
+/* end file src/simdutf/lsx/implementation.h */
+
+/* begin file src/simdutf/lsx/begin.h */
+// redefining SIMDUTF_IMPLEMENTATION to "lsx"
+// #define SIMDUTF_IMPLEMENTATION lsx
+#define SIMDUTF_SIMD_HAS_UNSIGNED_CMP 1
+/* end file src/simdutf/lsx/begin.h */
+
+  // Declarations
+/* begin file src/simdutf/lsx/intrinsics.h */
+#ifndef SIMDUTF_LSX_INTRINSICS_H
+#define SIMDUTF_LSX_INTRINSICS_H
 
-#if defined(__loongarch_asx)
-  #ifdef __clang__
-    #define VREGS_PREFIX "$vr"
-    #define XREGS_PREFIX "$xr"
-  #else // GCC
-    #define VREGS_PREFIX "$f"
-    #define XREGS_PREFIX "$f"
-  #endif
-  #define __ALL_REGS                                                           \
-    "0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,"  \
-    "27,28,29,30,31"
-// Convert __m128i to __m256i
-static inline __m256i ____m256i(__m128i in) {
-  __m256i out = __lasx_xvldi(0);
-  __asm__ volatile(".irp i," __ALL_REGS "\n\t"
-                   " .ifc %[out], " XREGS_PREFIX "\\i    \n\t"
-                   "  .irp j," __ALL_REGS "\n\t"
-                   "   .ifc %[in], " VREGS_PREFIX "\\j  \n\t"
-                   "    xvpermi.q $xr\\i, $xr\\j, 0x0  \n\t"
-                   "   .endif                           \n\t"
-                   "  .endr                             \n\t"
-                   " .endif                             \n\t"
-                   ".endr                               \n\t"
-                   : [out] "+f"(out)
-                   : [in] "f"(in));
-  return out;
-}
-// Convert two __m128i to __m256i
-static inline __m256i lasx_set_q(__m128i inhi, __m128i inlo) {
-  __m256i out;
-  __asm__ volatile(".irp i," __ALL_REGS "\n\t"
-                   " .ifc %[hi], " VREGS_PREFIX "\\i    \n\t"
-                   "  .irp j," __ALL_REGS "\n\t"
-                   "   .ifc %[lo], " VREGS_PREFIX "\\j  \n\t"
-                   "    xvpermi.q $xr\\i, $xr\\j, 0x20  \n\t"
-                   "   .endif                           \n\t"
-                   "  .endr                             \n\t"
-                   " .endif                             \n\t"
-                   ".endr                               \n\t"
-                   ".ifnc %[out], %[hi]                 \n\t"
-                   ".irp i," __ALL_REGS "\n\t"
-                   " .ifc %[out], " XREGS_PREFIX "\\i   \n\t"
-                   "  .irp j," __ALL_REGS "\n\t"
-                   "   .ifc %[hi], " VREGS_PREFIX "\\j  \n\t"
-                   "    xvori.b $xr\\i, $xr\\j, 0       \n\t"
-                   "   .endif                           \n\t"
-                   "  .endr                             \n\t"
-                   " .endif                             \n\t"
-                   ".endr                               \n\t"
-                   ".endif                              \n\t"
-                   : [out] "=f"(out), [hi] "+f"(inhi)
-                   : [lo] "f"(inlo));
-  return out;
-}
-// Convert __m256i low part to __m128i
-static inline __m128i lasx_extracti128_lo(__m256i in) {
-  __m128i out;
-  __asm__ volatile(".ifnc %[out], %[in]                 \n\t"
-                   ".irp i," __ALL_REGS "\n\t"
-                   " .ifc %[out], " VREGS_PREFIX "\\i   \n\t"
-                   "  .irp j," __ALL_REGS "\n\t"
-                   "   .ifc %[in], " XREGS_PREFIX "\\j  \n\t"
-                   "    vori.b $vr\\i, $vr\\j, 0        \n\t"
-                   "   .endif                           \n\t"
-                   "  .endr                             \n\t"
-                   " .endif                             \n\t"
-                   ".endr                               \n\t"
-                   ".endif                              \n\t"
-                   : [out] "=f"(out)
-                   : [in] "f"(in));
-  return out;
-}
-// Convert __m256i high part to __m128i
-static inline __m128i lasx_extracti128_hi(__m256i in) {
-  __m128i out;
-  __asm__ volatile(".irp i," __ALL_REGS "\n\t"
-                   " .ifc %[out], " VREGS_PREFIX "\\i   \n\t"
-                   "  .irp j," __ALL_REGS "\n\t"
-                   "   .ifc %[in], " XREGS_PREFIX "\\j  \n\t"
-                   "    xvpermi.q $xr\\i, $xr\\j, 0x11  \n\t"
-                   "   .endif                           \n\t"
-                   "  .endr                             \n\t"
-                   " .endif                             \n\t"
-                   ".endr                               \n\t"
-                   : [out] "=f"(out)
-                   : [in] "f"(in));
-  return out;
-}
-#endif
+
+// This should be the correct header whether
+// you use visual studio or other compilers.
+#include <lsxintrin.h>
 
 /*
 Encoding of argument for LoongArch64 xvldi instruction.  See:
@@ -9474,7 +8863,7 @@ all lanes
 the result as 64-bit elements to all lanes
 */
 
-namespace lasx_vldi {
+namespace vldi {
 
 template <uint16_t v> class const_u16 {
   constexpr static const uint8_t b0 = ((v >> 0 * 8) & 0xff);
@@ -9591,412 +8980,235 @@ template <uint64_t v> class const_u64 {
   constexpr static int value = int((operation << 8) | byte) - 8192;
   constexpr static bool valid = operation != 0xffff;
 };
+} // namespace vldi
 
-} // namespace lasx_vldi
-
-// Uncomment when running under QEMU affected
-// by bug https://gitlab.com/qemu-project/qemu/-/issues/2865
-// Versions <= 9.2.2 are affected, likely anything newer is correct.
-#ifndef QEMU_VLDI_BUG
-// #define QEMU_VLDI_BUG 1
-#endif
-
-#ifdef QEMU_VLDI_BUG
-  #define lasx_splat_u16(v) __lasx_xvreplgr2vr_h(v)
-  #define lasx_splat_u32(v) __lasx_xvreplgr2vr_w(v)
-#else
-template <uint16_t x> constexpr __m256i lasx_splat_u16_aux() {
-  constexpr bool is_imm10 = (int16_t(x) < 512) && (int16_t(x) > -512);
-  constexpr uint16_t imm10 = is_imm10 ? x : 0;
-  constexpr bool is_vldi = lasx_vldi::const_u16<x>::valid;
-  constexpr int vldi_imm = is_vldi ? lasx_vldi::const_u16<x>::value : 0;
-
-  return is_imm10  ? __lasx_xvrepli_h(int16_t(imm10))
-         : is_vldi ? __lasx_xvldi(vldi_imm)
-                   : __lasx_xvreplgr2vr_h(x);
-}
-
-template <uint32_t x> constexpr __m256i lasx_splat_u32_aux() {
-  constexpr bool is_imm10 = (int32_t(x) < 512) && (int32_t(x) > -512);
-  constexpr uint32_t imm10 = is_imm10 ? x : 0;
-  constexpr bool is_vldi = lasx_vldi::const_u32<x>::valid;
-  constexpr int vldi_imm = is_vldi ? lasx_vldi::const_u32<x>::value : 0;
-
-  return is_imm10  ? __lasx_xvrepli_w(int32_t(imm10))
-         : is_vldi ? __lasx_xvldi(vldi_imm)
-                   : __lasx_xvreplgr2vr_w(x);
-}
-
-  #define lasx_splat_u16(v) lasx_splat_u16_aux<(v)>()
-  #define lasx_splat_u32(v) lasx_splat_u32_aux<(v)>()
-#endif // QEMU_VLDI_BUG
-
-#endif //  SIMDUTF_LASX_INTRINSICS_H
-/* end file src/simdutf/lasx/intrinsics.h */
-/* begin file src/simdutf/lasx/bitmanipulation.h */
-#ifndef SIMDUTF_LASX_BITMANIPULATION_H
-#define SIMDUTF_LASX_BITMANIPULATION_H
-
-#include <limits>
-
-namespace simdutf {
-namespace lasx {
-namespace {
-
-simdutf_really_inline int count_ones(uint64_t input_num) {
-  return __lsx_vpickve2gr_w(__lsx_vpcnt_d(__lsx_vreplgr2vr_d(input_num)), 0);
-}
-
-#if SIMDUTF_NEED_TRAILING_ZEROES
-simdutf_really_inline int trailing_zeroes(uint64_t input_num) {
-  return __builtin_ctzll(input_num);
-}
-#endif
-
-} // unnamed namespace
-} // namespace lasx
-} // namespace simdutf
-
-#endif // SIMDUTF_LASX_BITMANIPULATION_H
-/* end file src/simdutf/lasx/bitmanipulation.h */
-/* begin file src/simdutf/lasx/simd.h */
-#ifndef SIMDUTF_LASX_SIMD_H
-#define SIMDUTF_LASX_SIMD_H
-
-
-namespace simdutf {
-namespace lasx {
-namespace {
-namespace simd {
-
-__attribute__((aligned(32))) static const uint8_t prev_shuf_table[32][32] = {
-    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
-    {0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-     31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
-    {0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
-     30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13},
-    {0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-     29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
-    {0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-     28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
-    {0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-     27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
-    {0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-     26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-    {0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7, 8,
-     25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6, 7,
-     24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5, 6,
-     23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4, 5,
-     22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3, 4,
-     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2, 3,
-     20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1, 2,
-     19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 1,
-     18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1},
-    {0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-     17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0},
-    {15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-     15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
-     14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
-     13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-     12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
-     11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-     10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
-     9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0,  0},
-    {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-     8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0,  0},
-    {7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
-     7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0,  0},
-    {6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-     6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0,  0},
-    {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-     5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0,  0},
-    {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
-     4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0,  0},
-    {3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
-     3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0,  0},
-    {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
-     2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0,  0},
-    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0},
-    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
-};
-
-__attribute__((aligned(32))) static const uint8_t bitsel_mask_table[32][32] = {
-    {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0,  0x0},
-    {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0}};
+// Uncomment when running under QEMU affected
+// by bug https://gitlab.com/qemu-project/qemu/-/issues/2865
+// Versions <= 9.2.2 are affected, likely anything newer is correct.
+#ifndef QEMU_VLDI_BUG
+// #define QEMU_VLDI_BUG 1
+#endif
 
-// Forward-declared so they can be used by splat and friends.
-template <typename Child> struct base {
-  __m256i value;
+#ifndef lsx_splat_u16
+  #ifdef QEMU_VLDI_BUG
+    #define lsx_splat_u16(v) __lsx_vreplgr2vr_h(v)
+    #define lsx_splat_u32(v) __lsx_vreplgr2vr_w(v)
+  #else
+namespace {
+template <uint16_t x> constexpr __m128i lsx_splat_u16_aux() {
+  return ((int16_t(x) < 512) && (int16_t(x) > -512))
+             ? __lsx_vrepli_h(
+                   ((int16_t(x) < 512) && (int16_t(x) > -512)) ? int16_t(x) : 0)
+             : (vldi::const_u16<x>::valid
+                    ? __lsx_vldi(vldi::const_u16<x>::valid
+                                     ? vldi::const_u16<x>::value
+                                     : 0)
+                    : __lsx_vreplgr2vr_h(x));
+}
 
-  // Zero constructor
-  simdutf_really_inline base() : value{__m256i()} {}
+template <uint32_t x> constexpr __m128i lsx_splat_u32_aux() {
+  return ((int32_t(x) < 512) && (int32_t(x) > -512))
+             ? __lsx_vrepli_w(
+                   ((int32_t(x) < 512) && (int32_t(x) > -512)) ? int32_t(x) : 0)
+             : (vldi::const_u32<x>::valid
+                    ? __lsx_vldi(vldi::const_u32<x>::valid
+                                     ? vldi::const_u32<x>::value
+                                     : 0)
+                    : __lsx_vreplgr2vr_w(x));
+}
+} // namespace
+    #define lsx_splat_u16(v) lsx_splat_u16_aux<(v)>()
+    #define lsx_splat_u32(v) lsx_splat_u32_aux<(v)>()
+  #endif // QEMU_VLDI_BUG
+#endif   // lsx_splat_u16
+#endif   //  SIMDUTF_LSX_INTRINSICS_H
+/* end file src/simdutf/lsx/intrinsics.h */
+/* begin file src/simdutf/lsx/bitmanipulation.h */
+#ifndef SIMDUTF_LSX_BITMANIPULATION_H
+#define SIMDUTF_LSX_BITMANIPULATION_H
 
-  // Conversion from SIMD register
-  simdutf_really_inline base(const __m256i _value) : value(_value) {}
-  // Conversion to SIMD register
-  simdutf_really_inline operator const __m256i &() const { return this->value; }
-  simdutf_really_inline operator __m256i &() { return this->value; }
-  template <endianness big_endian>
-  simdutf_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
-    if (big_endian) {
-      __m256i zero = __lasx_xvldi(0);
-      __m256i in8 = __lasx_xvpermi_d(this->value, 0b11011000);
-      __m256i inlow = __lasx_xvilvl_b(in8, zero);
-      __m256i inhigh = __lasx_xvilvh_b(in8, zero);
-      __lasx_xvst(inlow, reinterpret_cast<uint16_t *>(ptr), 0);
-      __lasx_xvst(inhigh, reinterpret_cast<uint16_t *>(ptr), 32);
-    } else {
-      __m256i inlow = __lasx_vext2xv_hu_bu(this->value);
-      __m256i inhigh = __lasx_vext2xv_hu_bu(
-          __lasx_xvpermi_q(this->value, this->value, 0b00000001));
-      __lasx_xvst(inlow, reinterpret_cast<__m256i *>(ptr), 0);
-      __lasx_xvst(inhigh, reinterpret_cast<__m256i *>(ptr), 32);
-    }
-  }
-  simdutf_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
-    __m256i in32_0 = __lasx_vext2xv_wu_bu(this->value);
-    __lasx_xvst(in32_0, reinterpret_cast<uint32_t *>(ptr), 0);
+#include <limits>
 
-    __m256i in8_1 = __lasx_xvpermi_d(this->value, 0b00000001);
-    __m256i in32_1 = __lasx_vext2xv_wu_bu(in8_1);
-    __lasx_xvst(in32_1, reinterpret_cast<uint32_t *>(ptr), 32);
+namespace simdutf {
+namespace lsx {
+namespace {
 
-    __m256i in8_2 = __lasx_xvpermi_d(this->value, 0b00000010);
-    __m256i in32_2 = __lasx_vext2xv_wu_bu(in8_2);
-    __lasx_xvst(in32_2, reinterpret_cast<uint32_t *>(ptr), 64);
+simdutf_really_inline int count_ones(uint64_t input_num) {
+  return __lsx_vpickve2gr_w(__lsx_vpcnt_d(__lsx_vreplgr2vr_d(input_num)), 0);
+}
+
+#if SIMDUTF_NEED_TRAILING_ZEROES
+simdutf_really_inline int trailing_zeroes(uint64_t input_num) {
+  return __builtin_ctzll(input_num);
+}
+#endif
+
+} // unnamed namespace
+} // namespace lsx
+} // namespace simdutf
+
+#endif // SIMDUTF_LSX_BITMANIPULATION_H
+/* end file src/simdutf/lsx/bitmanipulation.h */
+/* begin file src/simdutf/lsx/simd.h */
+#ifndef SIMDUTF_LSX_SIMD_H
+#define SIMDUTF_LSX_SIMD_H
+
+
+namespace simdutf {
+namespace lsx {
+namespace {
+namespace simd {
+
+template <typename T> struct simd8;
+
+//
+// Base class of simd8<uint8_t> and simd8<bool>, both of which use __m128i
+// internally.
+//
+template <typename T, typename Mask = simd8<bool>> struct base_u8 {
+  __m128i value;
+  static const int SIZE = sizeof(value);
+
+  // Conversion from/to SIMD register
+  simdutf_really_inline base_u8(const __m128i _value) : value(_value) {}
+  simdutf_really_inline operator const __m128i &() const { return this->value; }
+  simdutf_really_inline operator __m128i &() { return this->value; }
 
-    __m256i in8_3 = __lasx_xvpermi_d(this->value, 0b00000011);
-    __m256i in32_3 = __lasx_vext2xv_wu_bu(in8_3);
-    __lasx_xvst(in32_3, reinterpret_cast<uint32_t *>(ptr), 96);
-  }
   // Bit operations
-  simdutf_really_inline Child operator|(const Child other) const {
-    return __lasx_xvor_v(this->value, other);
+  simdutf_really_inline simd8<T> operator|(const simd8<T> other) const {
+    return __lsx_vor_v(this->value, other);
   }
-  simdutf_really_inline Child operator&(const Child other) const {
-    return __lasx_xvand_v(this->value, other);
+  simdutf_really_inline simd8<T> operator&(const simd8<T> other) const {
+    return __lsx_vand_v(this->value, other);
   }
-  simdutf_really_inline Child operator^(const Child other) const {
-    return __lasx_xvxor_v(this->value, other);
+  simdutf_really_inline simd8<T> operator^(const simd8<T> other) const {
+    return __lsx_vxor_v(this->value, other);
   }
-  simdutf_really_inline Child &operator|=(const Child other) {
-    auto this_cast = static_cast<Child *>(this);
+  simdutf_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
+  simdutf_really_inline simd8<T> &operator|=(const simd8<T> other) {
+    auto this_cast = static_cast<simd8<T> *>(this);
     *this_cast = *this_cast | other;
     return *this_cast;
   }
-};
-
-template <typename T> struct simd8;
 
-template <typename T, typename Mask = simd8<bool>>
-struct base8 : base<simd8<T>> {
-  simdutf_really_inline base8() : base<simd8<T>>() {}
-  simdutf_really_inline base8(const __m256i _value) : base<simd8<T>>(_value) {}
   friend simdutf_really_inline Mask operator==(const simd8<T> lhs,
                                                const simd8<T> rhs) {
-    return __lasx_xvseq_b(lhs, rhs);
+    return __lsx_vseq_b(lhs, rhs);
   }
 
-  static const int SIZE = sizeof(base<T>::value);
-
-  template <unsigned N = 1>
+  template <int N = 1>
   simdutf_really_inline simd8<T> prev(const simd8<T> prev_chunk) const {
-    static_assert(N <= 16, "unsupported shift value");
-
-    if (!N)
-      return this->value;
-
-    __m256i zero = __lasx_xvldi(0);
-    __m256i result, shuf;
-    if (N < 16) {
-      shuf = __lasx_xvld(prev_shuf_table[N], 0);
-
-      result = __lasx_xvshuf_b(
-          __lasx_xvpermi_q(this->value, this->value, 0b00000001), this->value,
-          shuf);
-      __m256i srl_prev = __lasx_xvbsrl_v(
-          __lasx_xvpermi_q(zero, prev_chunk.value, 0b00110001), (16 - N));
-      __m256i mask = __lasx_xvld(bitsel_mask_table[N], 0);
-      result = __lasx_xvbitsel_v(result, srl_prev, mask);
-
-      return result;
-    } else if (N == 16) {
-      return __lasx_xvpermi_q(this->value, prev_chunk.value, 0b00100001);
-    }
+    return __lsx_vor_v(__lsx_vbsll_v(this->value, N),
+                       __lsx_vbsrl_v(prev_chunk.value, 16 - N));
   }
 };
 
 // SIMD byte mask type (returned by things like eq and gt)
-template <> struct simd8<bool> : base8<bool> {
+template <> struct simd8<bool> : base_u8<bool> {
+  typedef uint16_t bitmask_t;
+  typedef uint32_t bitmask2_t;
+
   static simdutf_really_inline simd8<bool> splat(bool _value) {
-    return __lasx_xvreplgr2vr_b(uint8_t(-(!!_value)));
+    return __lsx_vreplgr2vr_b(uint8_t(-(!!_value)));
   }
 
-  simdutf_really_inline simd8() : base8() {}
-  simdutf_really_inline simd8(const __m256i _value) : base8<bool>(_value) {}
+  simdutf_really_inline simd8(const __m128i _value) : base_u8<bool>(_value) {}
+  // False constructor
+  simdutf_really_inline simd8() : simd8(__lsx_vldi(0)) {}
   // Splat constructor
-  simdutf_really_inline simd8(bool _value) : base8<bool>(splat(_value)) {}
+  simdutf_really_inline simd8(bool _value) : simd8(splat(_value)) {}
+  simdutf_really_inline void store(uint8_t dst[16]) const {
+    return __lsx_vst(this->value, dst, 0);
+  }
 
   simdutf_really_inline uint32_t to_bitmask() const {
-    __m256i mask = __lasx_xvmsknz_b(this->value);
-    uint32_t mask0 = __lasx_xvpickve2gr_wu(mask, 0);
-    uint32_t mask1 = __lasx_xvpickve2gr_wu(mask, 4);
-    return (mask0 | (mask1 << 16));
-  }
-  simdutf_really_inline bool any() const {
-    if (__lasx_xbz_b(this->value))
-      return false;
-    return true;
+    return __lsx_vpickve2gr_wu(__lsx_vmsknz_b(*this), 0);
   }
-  simdutf_really_inline simd8<bool> operator~() const { return *this ^ true; }
 };
 
-template <typename T> struct base8_numeric : base8<T> {
-  static simdutf_really_inline simd8<T> splat(T _value) {
-    return __lasx_xvreplgr2vr_b(_value);
+// Unsigned bytes
+template <> struct simd8<uint8_t> : base_u8<uint8_t> {
+  static simdutf_really_inline simd8<uint8_t> splat(uint8_t _value) {
+    return __lsx_vreplgr2vr_b(_value);
   }
-  static simdutf_really_inline simd8<T> zero() { return __lasx_xvldi(0); }
-  static simdutf_really_inline simd8<T> load(const T values[32]) {
-    return __lasx_xvld(reinterpret_cast<const __m256i *>(values), 0);
+  static simdutf_really_inline simd8<uint8_t> zero() { return __lsx_vldi(0); }
+  static simdutf_really_inline simd8<uint8_t> load(const uint8_t *values) {
+    return __lsx_vld(values, 0);
   }
+  simdutf_really_inline simd8(const __m128i _value)
+      : base_u8<uint8_t>(_value) {}
+  // Zero constructor
+  simdutf_really_inline simd8() : simd8(zero()) {}
+  // Array constructor
+  simdutf_really_inline simd8(const uint8_t values[16]) : simd8(load(values)) {}
+  // Splat constructor
+  simdutf_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
+  // Member-by-member initialization
+  simdutf_really_inline
+  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
+        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
+        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15)
+      : simd8((__m128i)v16u8{v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+                             v12, v13, v14, v15}) {}
+
   // Repeat 16 values as many times as necessary (usually for lookup tables)
-  static simdutf_really_inline simd8<T> repeat_16(T v0, T v1, T v2, T v3, T v4,
-                                                  T v5, T v6, T v7, T v8, T v9,
-                                                  T v10, T v11, T v12, T v13,
-                                                  T v14, T v15) {
-    return simd8<T>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
-                    v14, v15, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
-                    v12, v13, v14, v15);
+  simdutf_really_inline static simd8<uint8_t>
+  repeat_16(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4,
+            uint8_t v5, uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9,
+            uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14,
+            uint8_t v15) {
+    return simd8<uint8_t>(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
+                          v13, v14, v15);
   }
 
-  simdutf_really_inline base8_numeric() : base8<T>() {}
-  simdutf_really_inline base8_numeric(const __m256i _value)
-      : base8<T>(_value) {}
-
   // Store to array
-  simdutf_really_inline void store(T dst[32]) const {
-    return __lasx_xvst(this->value, reinterpret_cast<__m256i *>(dst), 0);
+  simdutf_really_inline void store(uint8_t dst[16]) const {
+    return __lsx_vst(this->value, dst, 0);
+  }
+
+  // Order-specific operations
+  simdutf_really_inline simd8<bool>
+  operator>=(const simd8<uint8_t> other) const {
+    return __lsx_vsle_bu(other, *this);
+  }
+  simdutf_really_inline simd8<bool>
+  operator>(const simd8<uint8_t> other) const {
+    return __lsx_vslt_bu(other, *this);
+  }
+  simdutf_really_inline simd8 &operator-=(const simd8<uint8_t> other) {
+    value = __lsx_vsub_b(value, other.value);
+    return *this;
+  }
+  // Same as >, but instead of guaranteeing all 1's == true, false = 0 and true
+  // = nonzero. For ARM, returns all 1's.
+  simdutf_really_inline simd8<uint8_t>
+  gt_bits(const simd8<uint8_t> other) const {
+    return simd8<uint8_t>(*this > other);
+  }
+
+  // Bit-specific operations
+  simdutf_really_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const {
+    return __lsx_vslt_bu(__lsx_vldi(0), __lsx_vand_v(this->value, bits));
+  }
+  simdutf_really_inline bool is_ascii() const {
+    return __lsx_vpickve2gr_hu(__lsx_vmskgez_b(this->value), 0) == 0xFFFF;
   }
 
-  // Override to distinguish from bool version
-  simdutf_really_inline simd8<T> operator~() const { return *this ^ 0xFFu; }
+  simdutf_really_inline bool any_bits_set_anywhere() const {
+    return __lsx_vpickve2gr_hu(__lsx_vmsknz_b(this->value), 0) > 0;
+  }
+  template <int N> simdutf_really_inline simd8<uint8_t> shr() const {
+    return __lsx_vsrli_b(this->value, N);
+  }
+  template <int N> simdutf_really_inline simd8<uint8_t> shl() const {
+    return __lsx_vslli_b(this->value, N);
+  }
 
   // Perform a lookup assuming the value is between 0 and 16 (undefined behavior
   // for out of range values)
   template <typename L>
   simdutf_really_inline simd8<L> lookup_16(simd8<L> lookup_table) const {
-    __m256i origin = __lasx_xvand_v(this->value, __lasx_xvldi(0x1f));
-    return __lasx_xvshuf_b(__lasx_xvldi(0), lookup_table, origin);
+    return lookup_table.apply_lookup_16_to(*this);
   }
 
   template <typename L>
@@ -10010,115 +9222,150 @@ template <typename T> struct base8_numeric : base8<T> {
         replace7, replace8, replace9, replace10, replace11, replace12,
         replace13, replace14, replace15));
   }
+
+  template <typename T>
+  simdutf_really_inline simd8<uint8_t>
+  apply_lookup_16_to(const simd8<T> original) const {
+    __m128i original_tmp = __lsx_vand_v(original, __lsx_vldi(0x1f));
+    return __lsx_vshuf_b(__lsx_vldi(0), *this, simd8<uint8_t>(original_tmp));
+  }
+
+  simdutf_really_inline uint64_t sum_bytes() const {
+    const auto sum_u16 = __lsx_vhaddw_hu_bu(value, value);
+    const auto sum_u32 = __lsx_vhaddw_wu_hu(sum_u16, sum_u16);
+    const auto sum_u64 = __lsx_vhaddw_du_wu(sum_u32, sum_u32);
+
+    return uint64_t(__lsx_vpickve2gr_du(sum_u64, 0)) +
+           uint64_t(__lsx_vpickve2gr_du(sum_u64, 1));
+  }
 };
 
 // Signed bytes
-template <> struct simd8<int8_t> : base8_numeric<int8_t> {
-  simdutf_really_inline simd8() : base8_numeric<int8_t>() {}
-  simdutf_really_inline simd8(const __m256i _value)
-      : base8_numeric<int8_t>(_value) {}
+template <> struct simd8<int8_t> {
+  __m128i value;
 
-  // Splat constructor
-  simdutf_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
-  // Array constructor
-  simdutf_really_inline simd8(const int8_t values[32]) : simd8(load(values)) {}
-  simdutf_really_inline operator simd8<uint8_t>() const;
-  simdutf_really_inline bool is_ascii() const {
-    __m256i ascii_mask = __lasx_xvslti_b(this->value, 0);
-    if (__lasx_xbnz_v(ascii_mask))
-      return false;
-    return true;
+  static const int SIZE = sizeof(value);
+
+  static simdutf_really_inline simd8<int8_t> splat(int8_t _value) {
+    return __lsx_vreplgr2vr_b(_value);
   }
-  // Order-sensitive comparisons
-  simdutf_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
-    return __lasx_xvslt_b(other, this->value);
+  static simdutf_really_inline simd8<int8_t> zero() { return __lsx_vldi(0); }
+  static simdutf_really_inline simd8<int8_t> load(const int8_t values[16]) {
+    return __lsx_vld(values, 0);
   }
-  simdutf_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
-    return __lasx_xvslt_b(this->value, other);
+
+  template <endianness big_endian>
+  simdutf_really_inline void store_ascii_as_utf16(char16_t *p) const {
+    __m128i zero = __lsx_vldi(0);
+    if constexpr (match_system(big_endian)) {
+      __lsx_vst(__lsx_vilvl_b(zero, (__m128i)this->value),
+                reinterpret_cast<uint16_t *>(p), 0);
+      __lsx_vst(__lsx_vilvh_b(zero, (__m128i)this->value),
+                reinterpret_cast<uint16_t *>(p + 8), 0);
+    } else {
+      __lsx_vst(__lsx_vilvl_b((__m128i)this->value, zero),
+                reinterpret_cast<uint16_t *>(p), 0);
+      __lsx_vst(__lsx_vilvh_b((__m128i)this->value, zero),
+                reinterpret_cast<uint16_t *>(p + 8), 0);
+    }
   }
-};
 
-// Unsigned bytes
-template <> struct simd8<uint8_t> : base8_numeric<uint8_t> {
-  simdutf_really_inline simd8() : base8_numeric<uint8_t>() {}
-  simdutf_really_inline simd8(const __m256i _value)
-      : base8_numeric<uint8_t>(_value) {}
+  simdutf_really_inline void store_ascii_as_utf32(char32_t *p) const {
+    __m128i zero = __lsx_vldi(0);
+    __m128i in16low = __lsx_vilvl_b(zero, (__m128i)this->value);
+    __m128i in16high = __lsx_vilvh_b(zero, (__m128i)this->value);
+    __m128i in32_0 = __lsx_vilvl_h(zero, in16low);
+    __m128i in32_1 = __lsx_vilvh_h(zero, in16low);
+    __m128i in32_2 = __lsx_vilvl_h(zero, in16high);
+    __m128i in32_3 = __lsx_vilvh_h(zero, in16high);
+    __lsx_vst(in32_0, reinterpret_cast<uint32_t *>(p), 0);
+    __lsx_vst(in32_1, reinterpret_cast<uint32_t *>(p + 4), 0);
+    __lsx_vst(in32_2, reinterpret_cast<uint32_t *>(p + 8), 0);
+    __lsx_vst(in32_3, reinterpret_cast<uint32_t *>(p + 12), 0);
+  }
+
+  // In places where the table can be reused, which is most uses in simdutf, it
+  // is worth it to do 4 table lookups, as there is no direct zero extension
+  // from u8 to u32.
+  simdutf_really_inline void store_ascii_as_utf32_tbl(char32_t *p) const {
+    const simd8<uint8_t> tb1{0, 255, 255, 255, 1, 255, 255, 255,
+                             2, 255, 255, 255, 3, 255, 255, 255};
+    const simd8<uint8_t> tb2{4, 255, 255, 255, 5, 255, 255, 255,
+                             6, 255, 255, 255, 7, 255, 255, 255};
+    const simd8<uint8_t> tb3{8,  255, 255, 255, 9,  255, 255, 255,
+                             10, 255, 255, 255, 11, 255, 255, 255};
+    const simd8<uint8_t> tb4{12, 255, 255, 255, 13, 255, 255, 255,
+                             14, 255, 255, 255, 15, 255, 255, 255};
+
+    // encourage store pairing and interleaving
+    const auto shuf1 = this->apply_lookup_16_to(tb1);
+    const auto shuf2 = this->apply_lookup_16_to(tb2);
+    shuf1.store(reinterpret_cast<int8_t *>(p));
+    shuf2.store(reinterpret_cast<int8_t *>(p + 4));
+
+    const auto shuf3 = this->apply_lookup_16_to(tb3);
+    const auto shuf4 = this->apply_lookup_16_to(tb4);
+    shuf3.store(reinterpret_cast<int8_t *>(p + 8));
+    shuf4.store(reinterpret_cast<int8_t *>(p + 12));
+  }
+  // Conversion from/to SIMD register
+  simdutf_really_inline simd8(const __m128i _value) : value(_value) {}
+
+  // Zero constructor
+  simdutf_really_inline simd8() : simd8(zero()) {}
   // Splat constructor
-  simdutf_really_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
+  simdutf_really_inline simd8(int8_t _value) : simd8(splat(_value)) {}
   // Array constructor
-  simdutf_really_inline simd8(const uint8_t values[32]) : simd8(load(values)) {}
-  // Member-by-member initialization
-  simdutf_really_inline
-  simd8(uint8_t v0, uint8_t v1, uint8_t v2, uint8_t v3, uint8_t v4, uint8_t v5,
-        uint8_t v6, uint8_t v7, uint8_t v8, uint8_t v9, uint8_t v10,
-        uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15,
-        uint8_t v16, uint8_t v17, uint8_t v18, uint8_t v19, uint8_t v20,
-        uint8_t v21, uint8_t v22, uint8_t v23, uint8_t v24, uint8_t v25,
-        uint8_t v26, uint8_t v27, uint8_t v28, uint8_t v29, uint8_t v30,
-        uint8_t v31)
-      : simd8((__m256i)v32u8{v0,  v1,  v2,  v3,  v4,  v5,  v6,  v7,
-                             v8,  v9,  v10, v11, v12, v13, v14, v15,
-                             v16, v17, v18, v19, v20, v21, v22, v23,
-                             v24, v25, v26, v27, v28, v29, v30, v31}) {}
+  simdutf_really_inline simd8(const int8_t *values) : simd8(load(values)) {}
 
-  // Saturated math
-  simdutf_really_inline simd8<uint8_t>
-  saturating_sub(const simd8<uint8_t> other) const {
-    return __lasx_xvssub_bu(this->value, other);
+  // Store to array
+  simdutf_really_inline void store(int8_t dst[16]) const {
+    return __lsx_vst(value, dst, 0);
   }
 
-  // Same as >, but only guarantees true is nonzero (< guarantees true = -1)
-  simdutf_really_inline simd8<uint8_t>
-  gt_bits(const simd8<uint8_t> other) const {
-    return this->saturating_sub(other);
-  }
-  simdutf_really_inline simd8<bool>
-  operator>=(const simd8<uint8_t> other) const {
-    return __lasx_xvsle_bu(other, *this);
+  simdutf_really_inline operator simd8<uint8_t>() const {
+    return ((__m128i)this->value);
   }
-  simdutf_really_inline simd8 &operator-=(const simd8<uint8_t> other) {
-    value = __lasx_xvsub_b(value, other.value);
-    return *this;
+
+  simdutf_really_inline simd8<int8_t>
+  operator|(const simd8<int8_t> other) const {
+    return __lsx_vor_v((__m128i)value, (__m128i)other.value);
   }
 
-  // Bit-specific operations
   simdutf_really_inline bool is_ascii() const {
-    __m256i ascii_mask = __lasx_xvslti_b(this->value, 0);
-    if (__lasx_xbnz_v(ascii_mask))
-      return false;
-    return true;
-  }
-  simdutf_really_inline bool any_bits_set_anywhere() const {
-    if (__lasx_xbnz_v(this->value))
-      return true;
-    return false;
+    return (__lsx_vpickve2gr_hu(__lsx_vmskgez_b((__m128i)this->value), 0) ==
+            0xffff);
   }
-  template <int N> simdutf_really_inline simd8<uint8_t> shr() const {
-    return __lasx_xvsrli_b(this->value, N);
+
+  // Order-sensitive comparisons
+  simdutf_really_inline simd8<bool> operator>(const simd8<int8_t> other) const {
+    return __lsx_vslt_b((__m128i)other.value, (__m128i)value);
   }
-  template <int N> simdutf_really_inline simd8<uint8_t> shl() const {
-    return __lasx_xvslli_b(this->value, N);
+  simdutf_really_inline simd8<bool> operator<(const simd8<int8_t> other) const {
+    return __lsx_vslt_b((__m128i)value, (__m128i)other.value);
   }
 
-  simdutf_really_inline uint64_t sum_bytes() const {
-    const auto sum_u16 = __lasx_xvhaddw_hu_bu(value, value);
-    const auto sum_u32 = __lasx_xvhaddw_wu_hu(sum_u16, sum_u16);
-    const auto sum_u64 = __lasx_xvhaddw_du_wu(sum_u32, sum_u32);
+  template <int N = 1>
+  simdutf_really_inline simd8<int8_t>
+  prev(const simd8<int8_t> prev_chunk) const {
+    return __lsx_vor_v(__lsx_vbsll_v(this->value, N),
+                       __lsx_vbsrl_v(prev_chunk.value, 16 - N));
+  }
 
-    return uint64_t(__lasx_xvpickve2gr_du(sum_u64, 0)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 1)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 2)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 3));
+  template <typename T>
+  simdutf_really_inline simd8<int8_t>
+  apply_lookup_16_to(const simd8<T> original) const {
+    __m128i original_tmp = __lsx_vand_v(original, __lsx_vldi(0x1f));
+    return __lsx_vshuf_b(__lsx_vldi(0), (__m128i)this->value,
+                         simd8<uint8_t>(original_tmp));
   }
 };
-simdutf_really_inline simd8<int8_t>::operator simd8<uint8_t>() const {
-  return this->value;
-}
 
 template <typename T> struct simd8x64 {
   static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
-  static_assert(NUM_CHUNKS == 2,
-                "LASX kernel should use two registers per 64-byte block.");
+  static_assert(
+      NUM_CHUNKS == 4,
+      "LoongArch kernel should use four registers per 64-byte block.");
   simd8<T> chunks[NUM_CHUNKS];
 
   simd8x64(const simd8x64<T> &o) = delete; // no copy allowed
@@ -10126,36 +9373,36 @@ template <typename T> struct simd8x64 {
   operator=(const simd8<T> other) = delete; // no assignment allowed
   simd8x64() = delete;                      // no default constructor allowed
 
-  simdutf_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1)
-      : chunks{chunk0, chunk1} {}
+  simdutf_really_inline simd8x64(const simd8<T> chunk0, const simd8<T> chunk1,
+                                 const simd8<T> chunk2, const simd8<T> chunk3)
+      : chunks{chunk0, chunk1, chunk2, chunk3} {}
   simdutf_really_inline simd8x64(const T *ptr)
       : chunks{simd8<T>::load(ptr),
-               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T))} {}
+               simd8<T>::load(ptr + sizeof(simd8<T>) / sizeof(T)),
+               simd8<T>::load(ptr + 2 * sizeof(simd8<T>) / sizeof(T)),
+               simd8<T>::load(ptr + 3 * sizeof(simd8<T>) / sizeof(T))} {}
 
   simdutf_really_inline void store(T *ptr) const {
     this->chunks[0].store(ptr + sizeof(simd8<T>) * 0 / sizeof(T));
     this->chunks[1].store(ptr + sizeof(simd8<T>) * 1 / sizeof(T));
-  }
-
-  simdutf_really_inline uint64_t to_bitmask() const {
-    uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
-    uint64_t r_hi = this->chunks[1].to_bitmask();
-    return r_lo | (r_hi << 32);
+    this->chunks[2].store(ptr + sizeof(simd8<T>) * 2 / sizeof(T));
+    this->chunks[3].store(ptr + sizeof(simd8<T>) * 3 / sizeof(T));
   }
 
   simdutf_really_inline simd8x64<T> &operator|=(const simd8x64<T> &other) {
     this->chunks[0] |= other.chunks[0];
     this->chunks[1] |= other.chunks[1];
+    this->chunks[2] |= other.chunks[2];
+    this->chunks[3] |= other.chunks[3];
     return *this;
   }
 
   simdutf_really_inline simd8<T> reduce_or() const {
-    return this->chunks[0] | this->chunks[1];
+    return (this->chunks[0] | this->chunks[1]) |
+           (this->chunks[2] | this->chunks[3]);
   }
 
-  simdutf_really_inline bool is_ascii() const {
-    return this->reduce_or().is_ascii();
-  }
+  simdutf_really_inline bool is_ascii() const { return reduce_or().is_ascii(); }
 
   template <endianness endian>
   simdutf_really_inline void store_ascii_as_utf16(char16_t *ptr) const {
@@ -10163,117 +9410,158 @@ template <typename T> struct simd8x64 {
                                                           sizeof(simd8<T>) * 0);
     this->chunks[1].template store_ascii_as_utf16<endian>(ptr +
                                                           sizeof(simd8<T>) * 1);
+    this->chunks[2].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 2);
+    this->chunks[3].template store_ascii_as_utf16<endian>(ptr +
+                                                          sizeof(simd8<T>) * 3);
   }
 
   simdutf_really_inline void store_ascii_as_utf32(char32_t *ptr) const {
-    this->chunks[0].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 0);
-    this->chunks[1].store_ascii_as_utf32(ptr + sizeof(simd8<T>) * 1);
+    this->chunks[0].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 0);
+    this->chunks[1].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 1);
+    this->chunks[2].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 2);
+    this->chunks[3].store_ascii_as_utf32_tbl(ptr + sizeof(simd8<T>) * 3);
+  }
+
+  simdutf_really_inline uint64_t to_bitmask() const {
+    __m128i mask = __lsx_vbsll_v(__lsx_vmsknz_b(this->chunks[3]), 6);
+    mask = __lsx_vor_v(mask, __lsx_vbsll_v(__lsx_vmsknz_b(this->chunks[2]), 4));
+    mask = __lsx_vor_v(mask, __lsx_vbsll_v(__lsx_vmsknz_b(this->chunks[1]), 2));
+    mask = __lsx_vor_v(mask, __lsx_vmsknz_b(this->chunks[0]));
+    return __lsx_vpickve2gr_du(mask, 0);
   }
 
   simdutf_really_inline uint64_t lt(const T m) const {
     const simd8<T> mask = simd8<T>::splat(m);
-    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask)
+    return simd8x64<bool>(this->chunks[0] < mask, this->chunks[1] < mask,
+                          this->chunks[2] < mask, this->chunks[3] < mask)
         .to_bitmask();
   }
-
   simdutf_really_inline uint64_t gt(const T m) const {
     const simd8<T> mask = simd8<T>::splat(m);
-    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask)
+    return simd8x64<bool>(this->chunks[0] > mask, this->chunks[1] > mask,
+                          this->chunks[2] > mask, this->chunks[3] > mask)
+        .to_bitmask();
+  }
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd8<T> mask = simd8<T>::splat(m);
+    return simd8x64<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                          this->chunks[2] >= mask, this->chunks[3] >= mask)
         .to_bitmask();
   }
   simdutf_really_inline uint64_t gteq_unsigned(const uint8_t m) const {
     const simd8<uint8_t> mask = simd8<uint8_t>::splat(m);
-    return simd8x64<bool>((simd8<uint8_t>(__m256i(this->chunks[0])) >= mask),
-                          (simd8<uint8_t>(__m256i(this->chunks[1])) >= mask))
+    return simd8x64<bool>(simd8<uint8_t>(this->chunks[0].value) >= mask,
+                          simd8<uint8_t>(this->chunks[1].value) >= mask,
+                          simd8<uint8_t>(this->chunks[2].value) >= mask,
+                          simd8<uint8_t>(this->chunks[3].value) >= mask)
         .to_bitmask();
   }
 }; // struct simd8x64<T>
 
-/* begin file src/simdutf/lasx/simd16-inl.h */
+/* begin file src/simdutf/lsx/simd16-inl.h */
 template <typename T> struct simd16;
 
+template <typename T, typename Mask = simd16<bool>> struct base_u16 {
+  __m128i value;
+  static const size_t SIZE = sizeof(value);
+  static const size_t ELEMENTS = sizeof(value) / sizeof(T);
+
+  // Conversion from/to SIMD register
+  simdutf_really_inline base_u16() = default;
+  simdutf_really_inline base_u16(const __m128i _value) : value(_value) {}
+  // Bit operations
+  simdutf_really_inline simd16<T> operator|(const simd16<T> other) const {
+    return __lsx_vor_v(this->value, other.value);
+  }
+  simdutf_really_inline simd16<T> operator&(const simd16<T> other) const {
+    return __lsx_vand_v(this->value, other.value);
+  }
+  simdutf_really_inline simd16<T> operator~() const {
+    return __lsx_vxori_b(this->value, 0xFF);
+  }
+
+  friend simdutf_really_inline Mask operator==(const simd16<T> lhs,
+                                               const simd16<T> rhs) {
+    return __lsx_vseq_h(lhs.value, rhs.value);
+  }
+
+  template <unsigned N>
+  simdutf_really_inline simd16<T> byte_right_shift() const {
+    return __lsx_vbsrl_v(this->value, N);
+  }
+
+  simdutf_really_inline uint16_t first() const {
+    return uint16_t(__lsx_vpickve2gr_w(value, 0));
+  }
+};
+
 template <typename T, typename Mask = simd16<bool>>
-struct base16 : base<simd16<T>> {
-  using bitmask_type = uint32_t;
+struct base16 : base_u16<T> {
+  using bitmask_type = uint16_t;
 
-  simdutf_really_inline base16() : base<simd16<T>>() {}
-  simdutf_really_inline base16(const __m256i _value)
-      : base<simd16<T>>(_value) {}
+  simdutf_really_inline base16() : base_u16<T>() {}
+  simdutf_really_inline base16(const __m128i _value) : base_u16<T>(_value) {}
   template <typename Pointer>
   simdutf_really_inline base16(const Pointer *ptr)
-      : base16(__lasx_xvld(reinterpret_cast<const __m256i *>(ptr), 0)) {}
+      : base16(__lsx_vld(ptr, 0)) {}
 
-  /// the size of vector in bytes
-  static const int SIZE = sizeof(base<simd16<T>>::value);
+  static const int SIZE = sizeof(base_u16<T>::value);
 
-  /// the number of elements of type T a vector can hold
-  static const int ELEMENTS = SIZE / sizeof(T);
+  template <unsigned N = 1>
+  simdutf_really_inline simd16<T> prev(const simd16<T> prev_chunk) const {
+    return __lsx_vor_v(__lsx_vbsll_v(*this, N * 2),
+                       __lsx_vbsrl_v(prev_chunk, 16 - N * 2));
+  }
 };
 
 // SIMD byte mask type (returned by things like eq and gt)
 template <> struct simd16<bool> : base16<bool> {
   static simdutf_really_inline simd16<bool> splat(bool _value) {
-    return __lasx_xvreplgr2vr_h(uint16_t(-(!!_value)));
+    return __lsx_vreplgr2vr_h(uint16_t(-(!!_value)));
   }
 
   simdutf_really_inline simd16() : base16() {}
-  simdutf_really_inline simd16(const __m256i _value) : base16<bool>(_value) {}
-  // Splat constructor
-  simdutf_really_inline simd16(bool _value) : base16<bool>(splat(_value)) {}
+  simdutf_really_inline simd16(const __m128i _value) : base16<bool>(_value) {}
 
   simdutf_really_inline bitmask_type to_bitmask() const {
-    __m256i mask = __lasx_xvmsknz_b(this->value);
-    bitmask_type mask0 = __lasx_xvpickve2gr_wu(mask, 0);
-    bitmask_type mask1 = __lasx_xvpickve2gr_wu(mask, 4);
-    return (mask0 | (mask1 << 16));
-  }
-  simdutf_really_inline simd16<bool> operator~() const { return *this ^ true; }
-
-  simdutf_really_inline bool is_zero() const {
-    return __lasx_xbz_v(this->value);
-  }
-
-  template <unsigned N> simdutf_really_inline simd16 byte_right_shift() const {
-    const auto t0 = __lasx_xvbsrl_v(this->value, N);
-    const auto t1 = __lasx_xvpermi_q(this->value, __lasx_xvldi(0), 0b00000011);
-    const auto t2 = __lasx_xvbsll_v(t1, 16 - N);
-    const auto t3 = __lasx_xvor_v(t0, t2);
-    return t3;
+    __m128i mask = __lsx_vmsknz_b(this->value);
+    bitmask_type mask0 = bitmask_type(__lsx_vpickve2gr_wu(mask, 0));
+    return mask0;
   }
 
-  simdutf_really_inline uint16_t first() const {
-    return uint16_t(__lasx_xvpickve2gr_w(value, 0));
-  }
+  simdutf_really_inline bool is_zero() const { return __lsx_bz_v(this->value); }
 };
 
 template <typename T> struct base16_numeric : base16<T> {
   static simdutf_really_inline simd16<T> splat(T _value) {
-    return __lasx_xvreplgr2vr_h((uint16_t)_value);
+    return __lsx_vreplgr2vr_h(_value);
   }
-  static simdutf_really_inline simd16<T> zero() { return __lasx_xvldi(0); }
+  static simdutf_really_inline simd16<T> zero() { return __lsx_vldi(0); }
+
   template <typename Pointer>
   static simdutf_really_inline simd16<T> load(const Pointer values) {
-    return __lasx_xvld(values, 0);
+    return __lsx_vld(values, 0);
   }
 
-  simdutf_really_inline base16_numeric() : base16<T>() {}
-  simdutf_really_inline base16_numeric(const __m256i _value)
+  simdutf_really_inline base16_numeric(const __m128i _value)
       : base16<T>(_value) {}
 
   // Store to array
   simdutf_really_inline void store(T dst[8]) const {
-    return __lasx_xvst(this->value, reinterpret_cast<__m256i *>(dst), 0);
+    return __lsx_vst(this->value, dst, 0);
   }
 
   // Override to distinguish from bool version
-  simdutf_really_inline simd16<T> operator~() const { return *this ^ 0xFFFFu; }
+  simdutf_really_inline simd16<T> operator~() const {
+    return __lsx_vxori_b(this->value, 0xFF);
+  }
 };
 
-// Unsigned code units
+// Unsigned code unitstemplate<>
 template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
-  simdutf_really_inline simd16() : base16_numeric<uint16_t>() {}
-  simdutf_really_inline simd16(const __m256i _value)
-      : base16_numeric<uint16_t>(_value) {}
+  simdutf_really_inline simd16(const __m128i _value)
+      : base16_numeric<uint16_t>((__m128i)_value) {}
 
   // Splat constructor
   simdutf_really_inline simd16(uint16_t _value) : simd16(splat(_value)) {}
@@ -10283,71 +9571,67 @@ template <> struct simd16<uint16_t> : base16_numeric<uint16_t> {
   simdutf_really_inline simd16(const char16_t *values)
       : simd16(load(reinterpret_cast<const uint16_t *>(values))) {}
 
+  // Copy constructor
+  simdutf_really_inline simd16(const simd16<bool> mask) : simd16(mask.value) {}
+
   // Order-specific operations
   simdutf_really_inline simd16 &operator+=(const simd16 other) {
-    value = __lasx_xvadd_h(value, other.value);
+    value = __lsx_vadd_h(value, other.value);
     return *this;
   }
 
-  // Change the endianness
-  simdutf_really_inline simd16<uint16_t> swap_bytes() const {
-    return __lasx_xvshuf4i_b(this->value, 0b10110001);
-  }
-
   template <unsigned N>
   static simdutf_really_inline simd8<uint8_t>
   pack_shifted_right(const simd16<uint16_t> &v0, const simd16<uint16_t> &v1) {
-    return __lasx_xvpermi_d(__lasx_xvssrlni_bu_h(v1.value, v0.value, N),
-                            0b11011000);
+    return __lsx_vssrlni_bu_h(v1.value, v0.value, N);
   }
 
   // Pack with the unsigned saturation of two uint16_t code units into single
   // uint8_t vector
   static simdutf_really_inline simd8<uint8_t> pack(const simd16<uint16_t> &v0,
                                                    const simd16<uint16_t> &v1) {
-
     return pack_shifted_right<0>(v0, v1);
   }
 
-  simdutf_really_inline uint64_t sum() const {
-    const auto sum_u32 = __lasx_xvhaddw_wu_hu(value, value);
-    const auto sum_u64 = __lasx_xvhaddw_du_wu(sum_u32, sum_u32);
-
-    return uint64_t(__lasx_xvpickve2gr_du(sum_u64, 0)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 1)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 2)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum_u64, 3));
+  // Change the endianness
+  simdutf_really_inline simd16<uint16_t> swap_bytes() const {
+    return __lsx_vshuf4i_b(this->value, 0b10110001);
   }
 
-  template <unsigned N> simdutf_really_inline simd16 byte_right_shift() const {
-    return __lasx_xvbsrl_v(this->value, N);
+  simdutf_really_inline uint64_t sum() const {
+    const auto sum_u32 = __lsx_vhaddw_wu_hu(value, value);
+    const auto sum_u64 = __lsx_vhaddw_du_wu(sum_u32, sum_u32);
+
+    return uint64_t(__lsx_vpickve2gr_du(sum_u64, 0)) +
+           uint64_t(__lsx_vpickve2gr_du(sum_u64, 1));
   }
 };
 
 simdutf_really_inline simd16<bool> operator<(const simd16<uint16_t> a,
                                              const simd16<uint16_t> b) {
-  return __lasx_xvslt_hu(a.value, b.value);
+  return __lsx_vslt_hu(a.value, b.value);
 }
 
 simdutf_really_inline simd16<bool> operator>(const simd16<uint16_t> a,
                                              const simd16<uint16_t> b) {
-  return __lasx_xvslt_hu(b.value, a.value);
+  return __lsx_vslt_hu(b.value, a.value);
 }
 
 simdutf_really_inline simd16<bool> operator<=(const simd16<uint16_t> a,
                                               const simd16<uint16_t> b) {
-  return __lasx_xvsle_hu(a.value, b.value);
+  return __lsx_vsle_hu(a.value, b.value);
 }
 
 simdutf_really_inline simd16<bool> operator>=(const simd16<uint16_t> a,
                                               const simd16<uint16_t> b) {
-  return __lasx_xvsle_hu(b.value, a.value);
+  return __lsx_vsle_hu(b.value, a.value);
 }
 
 template <typename T> struct simd16x32 {
   static constexpr int NUM_CHUNKS = 64 / sizeof(simd16<T>);
-  static_assert(NUM_CHUNKS == 2,
-                "LASX kernel should use two registers per 64-byte block.");
+  static_assert(
+      NUM_CHUNKS == 4,
+      "LOONGARCH kernel should use four registers per 64-byte block.");
   simd16<T> chunks[NUM_CHUNKS];
 
   simd16x32(const simd16x32<T> &o) = delete; // no copy allowed
@@ -10355,139 +9639,133 @@ template <typename T> struct simd16x32 {
   operator=(const simd16<T> other) = delete; // no assignment allowed
   simd16x32() = delete;                      // no default constructor allowed
 
-  simdutf_really_inline simd16x32(const simd16<T> chunk0,
-                                  const simd16<T> chunk1)
-      : chunks{chunk0, chunk1} {}
+  simdutf_really_inline
+  simd16x32(const simd16<T> chunk0, const simd16<T> chunk1,
+            const simd16<T> chunk2, const simd16<T> chunk3)
+      : chunks{chunk0, chunk1, chunk2, chunk3} {}
   simdutf_really_inline simd16x32(const T *ptr)
       : chunks{simd16<T>::load(ptr),
-               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T))} {}
+               simd16<T>::load(ptr + sizeof(simd16<T>) / sizeof(T)),
+               simd16<T>::load(ptr + 2 * sizeof(simd16<T>) / sizeof(T)),
+               simd16<T>::load(ptr + 3 * sizeof(simd16<T>) / sizeof(T))} {}
 
   simdutf_really_inline void store(T *ptr) const {
     this->chunks[0].store(ptr + sizeof(simd16<T>) * 0 / sizeof(T));
     this->chunks[1].store(ptr + sizeof(simd16<T>) * 1 / sizeof(T));
+    this->chunks[2].store(ptr + sizeof(simd16<T>) * 2 / sizeof(T));
+    this->chunks[3].store(ptr + sizeof(simd16<T>) * 3 / sizeof(T));
   }
 
   simdutf_really_inline void swap_bytes() {
     this->chunks[0] = this->chunks[0].swap_bytes();
     this->chunks[1] = this->chunks[1].swap_bytes();
+    this->chunks[2] = this->chunks[2].swap_bytes();
+    this->chunks[3] = this->chunks[3].swap_bytes();
   }
   simdutf_really_inline uint64_t to_bitmask() const {
-    uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
-    uint64_t r_hi = this->chunks[1].to_bitmask();
-    return r_lo | (r_hi << 32);
+    uint64_t r0 = uint32_t(this->chunks[0].to_bitmask());
+    uint64_t r1 = this->chunks[1].to_bitmask();
+    uint64_t r2 = this->chunks[2].to_bitmask();
+    uint64_t r3 = this->chunks[3].to_bitmask();
+    return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);
+  }
+  simdutf_really_inline uint64_t gteq(const T m) const {
+    const simd16<T> mask = simd16<T>::splat(m);
+    return simd16x32<bool>(this->chunks[0] >= mask, this->chunks[1] >= mask,
+                           this->chunks[2] >= mask, this->chunks[3] >= mask)
+        .to_bitmask();
   }
   simdutf_really_inline uint64_t lteq(const T m) const {
     const simd16<T> mask = simd16<T>::splat(m);
-    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask)
+    return simd16x32<bool>(this->chunks[0] <= mask, this->chunks[1] <= mask,
+                           this->chunks[2] <= mask, this->chunks[3] <= mask)
         .to_bitmask();
   }
 }; // struct simd16x32<T>
 
-simdutf_really_inline simd16<uint16_t> min(const simd16<uint16_t> a,
-                                           const simd16<uint16_t> b) {
-  return __lasx_xvmin_hu(a.value, b.value);
-}
-
-simdutf_really_inline simd16<bool> operator==(const simd16<uint16_t> a,
-                                              uint16_t b) {
-  const auto bv = __lasx_xvreplgr2vr_h(b);
-  return __lasx_xvseq_h(a.value, bv);
-}
-
-simdutf_really_inline simd16<uint16_t> as_vector_u16(const simd16<bool> x) {
-  return x.value;
-}
-
-simdutf_really_inline simd16<uint16_t> operator&(const simd16<uint16_t> a,
+simdutf_really_inline simd16<uint16_t> operator^(const simd16<uint16_t> a,
                                                  uint16_t b) {
-  const auto bv = __lasx_xvreplgr2vr_h(b);
-  return __lasx_xvand_v(a.value, bv);
+  const auto bv = __lsx_vreplgr2vr_h(b);
+  return __lsx_vxor_v(a.value, bv);
 }
 
-simdutf_really_inline simd16<uint16_t> operator&(const simd16<uint16_t> a,
-                                                 const simd16<uint16_t> b) {
-  return __lasx_xvand_v(a.value, b.value);
+simdutf_really_inline simd16<bool> operator^(const simd16<bool> a,
+                                             const simd16<bool> b) {
+  return __lsx_vxor_v(a.value, b.value);
 }
 
-simdutf_really_inline simd16<uint16_t> operator^(const simd16<uint16_t> a,
-                                                 uint16_t b) {
-  const auto bv = __lasx_xvreplgr2vr_h(b);
-  return __lasx_xvxor_v(a.value, bv);
+simdutf_really_inline simd16<uint16_t> min(const simd16<uint16_t> a,
+                                           const simd16<uint16_t> b) {
+  return __lsx_vmin_hu(a.value, b.value);
 }
 
-simdutf_really_inline simd16<bool> operator^(const simd16<bool> a,
-                                             const simd16<bool> b) {
-  return __lasx_xvxor_v(a.value, b.value);
+simdutf_really_inline simd16<uint16_t> as_vector_u16(const simd16<bool> x) {
+  return x.value;
 }
-/* end file src/simdutf/lasx/simd16-inl.h */
-/* begin file src/simdutf/lasx/simd32-inl.h */
+/* end file src/simdutf/lsx/simd16-inl.h */
+/* begin file src/simdutf/lsx/simd32-inl.h */
 template <typename T> struct simd32;
 
 template <> struct simd32<uint32_t> {
-  __m256i value;
+  __m128i value;
   static const int SIZE = sizeof(value);
   static const int ELEMENTS = SIZE / sizeof(uint32_t);
 
   // constructors
-  simdutf_really_inline simd32(__m256i v) : value(v) {}
+  simdutf_really_inline simd32(__m128i v) : value(v) {}
 
   template <typename Ptr>
-  simdutf_really_inline simd32(Ptr *ptr) : value(__lasx_xvld(ptr, 0)) {}
+  simdutf_really_inline simd32(Ptr *ptr) : value(__lsx_vld(ptr, 0)) {}
 
   // in-place operators
   simdutf_really_inline simd32 &operator-=(const simd32 other) {
-    value = __lasx_xvsub_w(value, other.value);
+    value = __lsx_vsub_w(value, other.value);
     return *this;
   }
 
   // members
   simdutf_really_inline uint64_t sum() const {
-    const auto odd = __lasx_xvsrli_d(value, 32);
-    const auto even = __lasx_xvand_v(value, __lasx_xvreplgr2vr_d(0xffffffff));
-
-    const auto sum64 = __lasx_xvadd_d(odd, even);
-
-    return uint64_t(__lasx_xvpickve2gr_du(sum64, 0)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum64, 1)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum64, 2)) +
-           uint64_t(__lasx_xvpickve2gr_du(sum64, 3));
+    return uint64_t(__lsx_vpickve2gr_wu(value, 0)) +
+           uint64_t(__lsx_vpickve2gr_wu(value, 1)) +
+           uint64_t(__lsx_vpickve2gr_wu(value, 2)) +
+           uint64_t(__lsx_vpickve2gr_wu(value, 3));
   }
 
   // static members
   static simdutf_really_inline simd32<uint32_t> splat(uint32_t x) {
-    return __lasx_xvreplgr2vr_w(x);
+    return __lsx_vreplgr2vr_w(x);
   }
 
   static simdutf_really_inline simd32<uint32_t> zero() {
-    return __lasx_xvrepli_w(0);
+    return __lsx_vrepli_w(0);
   }
 };
 
 // ------------------------------------------------------------
 
 template <> struct simd32<bool> {
-  __m256i value;
+  __m128i value;
   static const int SIZE = sizeof(value);
 
   // constructors
-  simdutf_really_inline simd32(__m256i v) : value(v) {}
+  simdutf_really_inline simd32(__m128i v) : value(v) {}
 };
 
 // ------------------------------------------------------------
 
 simdutf_really_inline simd32<uint32_t> operator&(const simd32<uint32_t> a,
                                                  const simd32<uint32_t> b) {
-  return __lasx_xvor_v(a.value, b.value);
+  return __lsx_vor_v(a.value, b.value);
 }
 
 simdutf_really_inline simd32<bool> operator<(const simd32<uint32_t> a,
                                              const simd32<uint32_t> b) {
-  return __lasx_xvslt_wu(a.value, b.value);
+  return __lsx_vslt_wu(a.value, b.value);
 }
 
 simdutf_really_inline simd32<bool> operator>(const simd32<uint32_t> a,
                                              const simd32<uint32_t> b) {
-  return __lasx_xvslt_wu(b.value, a.value);
+  return __lsx_vslt_wu(b.value, a.value);
 }
 
 // ------------------------------------------------------------
@@ -10495,78 +9773,76 @@ simdutf_really_inline simd32<bool> operator>(const simd32<uint32_t> a,
 simdutf_really_inline simd32<uint32_t> as_vector_u32(const simd32<bool> v) {
   return v.value;
 }
-/* end file src/simdutf/lasx/simd32-inl.h */
-/* begin file src/simdutf/lasx/simd64-inl.h */
+/* end file src/simdutf/lsx/simd32-inl.h */
+/* begin file src/simdutf/lsx/simd64-inl.h */
 template <typename T> struct simd64;
 
 template <> struct simd64<uint64_t> {
-  __m256i value;
+  __m128i value;
   static const int SIZE = sizeof(value);
   static const int ELEMENTS = SIZE / sizeof(uint64_t);
 
   // constructors
-  simdutf_really_inline simd64(__m256i v) : value(v) {}
+  simdutf_really_inline simd64(__m128i v) : value(v) {}
 
   template <typename Ptr>
-  simdutf_really_inline simd64(Ptr *ptr) : value(__lasx_xvld(ptr, 0)) {}
+  simdutf_really_inline simd64(Ptr *ptr) : value(__lsx_vld(ptr, 0)) {}
 
   // in-place operators
   simdutf_really_inline simd64 &operator+=(const simd64 other) {
-    value = __lasx_xvadd_d(value, other.value);
+    value = __lsx_vadd_d(value, other.value);
     return *this;
   }
 
   // members
   simdutf_really_inline uint64_t sum() const {
-    return uint64_t(__lasx_xvpickve2gr_du(value, 0)) +
-           uint64_t(__lasx_xvpickve2gr_du(value, 1)) +
-           uint64_t(__lasx_xvpickve2gr_du(value, 2)) +
-           uint64_t(__lasx_xvpickve2gr_du(value, 3));
+    return uint64_t(__lsx_vpickve2gr_du(value, 0)) +
+           uint64_t(__lsx_vpickve2gr_du(value, 1));
   }
 
   // static members
   static simdutf_really_inline simd64<uint64_t> zero() {
-    return __lasx_xvrepli_d(0);
+    return __lsx_vrepli_d(0);
   }
 };
 
 // ------------------------------------------------------------
 
 template <> struct simd64<bool> {
-  __m256i value;
+  __m128i value;
   static const int SIZE = sizeof(value);
 
   // constructors
-  simdutf_really_inline simd64(__m256i v) : value(v) {}
+  simdutf_really_inline simd64(__m128i v) : value(v) {}
 };
 
 // ------------------------------------------------------------
 
 simd64<uint64_t> sum_8bytes(const simd8<uint8_t> v) {
-  const auto sum_u16 = __lasx_xvhaddw_hu_bu(v, v);
-  const auto sum_u32 = __lasx_xvhaddw_wu_hu(sum_u16, sum_u16);
-  const auto sum_u64 = __lasx_xvhaddw_du_wu(sum_u32, sum_u32);
+  const auto sum_u16 = __lsx_vhaddw_hu_bu(v, v);
+  const auto sum_u32 = __lsx_vhaddw_wu_hu(sum_u16, sum_u16);
+  const auto sum_u64 = __lsx_vhaddw_du_wu(sum_u32, sum_u32);
 
   return simd64<uint64_t>(sum_u64);
 }
-/* end file src/simdutf/lasx/simd64-inl.h */
+/* end file src/simdutf/lsx/simd64-inl.h */
 
 } // namespace simd
 } // unnamed namespace
-} // namespace lasx
+} // namespace lsx
 } // namespace simdutf
 
-#endif // SIMDUTF_LASX_SIMD_H
-/* end file src/simdutf/lasx/simd.h */
+#endif // SIMDUTF_LSX_SIMD_H
+/* end file src/simdutf/lsx/simd.h */
 
-/* begin file src/simdutf/lasx/end.h */
+/* begin file src/simdutf/lsx/end.h */
 #undef SIMDUTF_SIMD_HAS_UNSIGNED_CMP
-/* end file src/simdutf/lasx/end.h */
+/* end file src/simdutf/lsx/end.h */
 
-#endif // SIMDUTF_IMPLEMENTATION_LASX
+#endif // SIMDUTF_IMPLEMENTATION_LSX
 
-#endif // SIMDUTF_LASX_H
-/* end file src/simdutf/lasx.h */
+#endif // SIMDUTF_LSX_H
+/* end file src/simdutf/lsx.h */
 /* begin file src/simdutf/fallback.h */
 #ifndef SIMDUTF_FALLBACK_H
 #define SIMDUTF_FALLBACK_H
@@ -10619,890 +9895,123 @@ class implementation final : public simdutf::implementation {
   simdutf_warn_unused result base64_to_binary(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
+          last_chunk_handling_options::loose) const noexcept override;
   simdutf_warn_unused full_result base64_to_binary_details(
       const char *input, size_t length, char *output, base64_options options,
       last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused result
-  base64_to_binary(const char16_t *input, size_t length, char *output,
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options =
-                       last_chunk_handling_options::loose) const noexcept;
-  simdutf_warn_unused full_result base64_to_binary_details(
-      const char16_t *input, size_t length, char *output,
-      base64_options options,
-      last_chunk_handling_options last_chunk_options =
-          last_chunk_handling_options::loose) const noexcept;
-  size_t binary_to_base64(const char *input, size_t length, char *output,
-                          base64_options options) const noexcept;
-  const char *find(const char *start, const char *end,
-                   char character) const noexcept;
-  const char16_t *find(const char16_t *start, const char16_t *end,
-                       char16_t character) const noexcept;
-
-};
-} // namespace fallback
-} // namespace simdutf
-
-#endif // SIMDUTF_FALLBACK_IMPLEMENTATION_H
-/* end file src/simdutf/fallback/implementation.h */
-
-/* begin file src/simdutf/fallback/begin.h */
-// redefining SIMDUTF_IMPLEMENTATION to "fallback"
-// #define SIMDUTF_IMPLEMENTATION fallback
-/* end file src/simdutf/fallback/begin.h */
-
-  // Declarations
-/* begin file src/simdutf/fallback/bitmanipulation.h */
-#ifndef SIMDUTF_FALLBACK_BITMANIPULATION_H
-#define SIMDUTF_FALLBACK_BITMANIPULATION_H
-
-#include <limits>
-
-namespace simdutf {
-namespace fallback {
-namespace {} // unnamed namespace
-} // namespace fallback
-} // namespace simdutf
-
-#endif // SIMDUTF_FALLBACK_BITMANIPULATION_H
-/* end file src/simdutf/fallback/bitmanipulation.h */
-
-/* begin file src/simdutf/fallback/end.h */
-/* end file src/simdutf/fallback/end.h */
-
-#endif // SIMDUTF_IMPLEMENTATION_FALLBACK
-#endif // SIMDUTF_FALLBACK_H
-/* end file src/simdutf/fallback.h */
-#ifndef SIMDUTF_REGULAR_VISUAL_STUDIO
-SIMDUTF_POP_DISABLE_WARNINGS
-#endif
-
-// The scalar routines should be included once.
-/* begin file src/scalar/swap_bytes.h */
-#ifndef SIMDUTF_SWAP_BYTES_H
-#define SIMDUTF_SWAP_BYTES_H
-
-namespace simdutf {
-namespace scalar {
-
-inline simdutf_warn_unused uint16_t u16_swap_bytes(const uint16_t word) {
-  return uint16_t((word >> 8) | (word << 8));
-}
-
-inline simdutf_warn_unused uint32_t u32_swap_bytes(const uint32_t word) {
-  return ((word >> 24) & 0xff) |      // move byte 3 to byte 0
-         ((word << 8) & 0xff0000) |   // move byte 1 to byte 2
-         ((word >> 8) & 0xff00) |     // move byte 2 to byte 1
-         ((word << 24) & 0xff000000); // byte 0 to byte 3
-}
-
-} // namespace scalar
-} // namespace simdutf
-
-#endif
-/* end file src/scalar/swap_bytes.h */
-/* begin file src/scalar/base64.h */
-#ifndef SIMDUTF_BASE64_H
-#define SIMDUTF_BASE64_H
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <iostream>
-
-namespace simdutf {
-namespace scalar {
-namespace {
-namespace base64 {
-
-// This function is not expected to be fast. Do not use in long loops.
-// In most instances you should be using is_ignorable.
-template <class char_type> bool is_ascii_white_space(char_type c) {
-  return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
-}
-
-template <class char_type> bool is_eight_byte(char_type c) {
-  if (sizeof(char_type) == 1) {
-    return true;
-  }
-  return uint8_t(c) == c;
-}
-
-template <class char_type>
-bool is_ignorable(char_type c, simdutf::base64_options options) {
-  const uint8_t *to_base64 =
-      (options & base64_default_or_url)
-          ? tables::base64::to_base64_default_or_url_value
-          : ((options & base64_url) ? tables::base64::to_base64_url_value
-                                    : tables::base64::to_base64_value);
-  const bool ignore_garbage =
-      (options == base64_options::base64_url_accept_garbage) ||
-      (options == base64_options::base64_default_accept_garbage) ||
-      (options == base64_options::base64_default_or_url_accept_garbage);
-  uint8_t code = to_base64[uint8_t(c)];
-  if (is_eight_byte(c) && code <= 63) {
-    return false;
-  }
-  if (is_eight_byte(c) && code == 64) {
-    return true;
-  }
-  return ignore_garbage;
-}
-template <class char_type>
-bool is_base64(char_type c, simdutf::base64_options options) {
-  const uint8_t *to_base64 =
-      (options & base64_default_or_url)
-          ? tables::base64::to_base64_default_or_url_value
-          : ((options & base64_url) ? tables::base64::to_base64_url_value
-                                    : tables::base64::to_base64_value);
-  uint8_t code = to_base64[uint8_t(c)];
-  if (is_eight_byte(c) && code <= 63) {
-    return true;
-  }
-  return false;
-}
-
-template <class char_type>
-bool is_base64_or_padding(char_type c, simdutf::base64_options options) {
-  const uint8_t *to_base64 =
-      (options & base64_default_or_url)
-          ? tables::base64::to_base64_default_or_url_value
-          : ((options & base64_url) ? tables::base64::to_base64_url_value
-                                    : tables::base64::to_base64_value);
-  if (c == '=') {
-    return true;
-  }
-  uint8_t code = to_base64[uint8_t(c)];
-  if (is_eight_byte(c) && code <= 63) {
-    return true;
-  }
-  return false;
-}
-
-template <class char_type>
-bool is_ignorable_or_padding(char_type c, simdutf::base64_options options) {
-  return is_ignorable(c, options) || c == '=';
-}
-
-struct reduced_input {
-  size_t equalsigns;    // number of padding characters '=', typically 0, 1, 2.
-  size_t equallocation; // location of the first padding character if any
-  size_t srclen;        // length of the input buffer before padding
-  size_t full_input_length; // length of the input buffer with padding but
-                            // without ignorable characters
-};
-
-// find the end of the base64 input buffer
-// It returns the number of padding characters, the location of the first
-// padding character if any, the length of the input buffer before padding
-// and the length of the input buffer with padding. The input buffer is not
-// modified. The function assumes that there are at most two padding characters.
-template <class char_type>
-reduced_input find_end(const char_type *src, size_t srclen,
-                       simdutf::base64_options options) {
-  const uint8_t *to_base64 =
-      (options & base64_default_or_url)
-          ? tables::base64::to_base64_default_or_url_value
-          : ((options & base64_url) ? tables::base64::to_base64_url_value
-                                    : tables::base64::to_base64_value);
-  const bool ignore_garbage =
-      (options == base64_options::base64_url_accept_garbage) ||
-      (options == base64_options::base64_default_accept_garbage) ||
-      (options == base64_options::base64_default_or_url_accept_garbage);
-
-  size_t equalsigns = 0;
-  // We intentionally include trailing spaces in the full input length.
-  // See https://github.com/simdutf/simdutf/issues/824
-  size_t full_input_length = srclen;
-  // skip trailing spaces
-  while (!ignore_garbage && srclen > 0 &&
-         scalar::base64::is_eight_byte(src[srclen - 1]) &&
-         to_base64[uint8_t(src[srclen - 1])] == 64) {
-    srclen--;
-  }
-  size_t equallocation =
-      srclen; // location of the first padding character if any
-  if (ignore_garbage) {
-    // Technically, we don't need to find the first padding character, we can
-    // just change our algorithms, but it adds substantial complexity.
-    auto it = simdutf::find(src, src + srclen, '=');
-    if (it != src + srclen) {
-      equallocation = it - src;
-      equalsigns = 1;
-      srclen = equallocation;
-      full_input_length = equallocation + 1;
-    }
-    return {equalsigns, equallocation, srclen, full_input_length};
-  }
-  if (!ignore_garbage && srclen > 0 && src[srclen - 1] == '=') {
-    // This is the last '=' sign.
-    equallocation = srclen - 1;
-    srclen--;
-    equalsigns = 1;
-    // skip trailing spaces
-    while (srclen > 0 && scalar::base64::is_eight_byte(src[srclen - 1]) &&
-           to_base64[uint8_t(src[srclen - 1])] == 64) {
-      srclen--;
-    }
-    if (srclen > 0 && src[srclen - 1] == '=') {
-      // This is the second '=' sign.
-      equallocation = srclen - 1;
-      srclen--;
-      equalsigns = 2;
-    }
-  }
-  return {equalsigns, equallocation, srclen, full_input_length};
-}
-
-// Returns true upon success. The destination buffer must be large enough.
-// This functions assumes that the padding (=) has been removed.
-// if check_capacity is true, it will check that the destination buffer is
-// large enough. If it is not, it will return OUTPUT_BUFFER_TOO_SMALL.
-template <bool check_capacity, class char_type>
-full_result base64_tail_decode_impl(
-    char *dst, size_t outlen, const char_type *src, size_t length,
-    size_t padding_characters, // number of padding characters
-                               // '=', typically 0, 1, 2.
-    base64_options options, last_chunk_handling_options last_chunk_options) {
-  char *dstend = dst + outlen;
-  (void)dstend;
-  // This looks like 10 branches, but we expect the compiler to resolve this to
-  // two branches (easily predicted):
-  const uint8_t *to_base64 =
-      (options & base64_default_or_url)
-          ? tables::base64::to_base64_default_or_url_value
-          : ((options & base64_url) ? tables::base64::to_base64_url_value
-                                    : tables::base64::to_base64_value);
-  const uint32_t *d0 =
-      (options & base64_default_or_url)
-          ? tables::base64::base64_default_or_url::d0
-          : ((options & base64_url) ? tables::base64::base64_url::d0
-                                    : tables::base64::base64_default::d0);
-  const uint32_t *d1 =
-      (options & base64_default_or_url)
-          ? tables::base64::base64_default_or_url::d1
-          : ((options & base64_url) ? tables::base64::base64_url::d1
-                                    : tables::base64::base64_default::d1);
-  const uint32_t *d2 =
-      (options & base64_default_or_url)
-          ? tables::base64::base64_default_or_url::d2
-          : ((options & base64_url) ? tables::base64::base64_url::d2
-                                    : tables::base64::base64_default::d2);
-  const uint32_t *d3 =
-      (options & base64_default_or_url)
-          ? tables::base64::base64_default_or_url::d3
-          : ((options & base64_url) ? tables::base64::base64_url::d3
-                                    : tables::base64::base64_default::d3);
-  const bool ignore_garbage =
-      (options == base64_options::base64_url_accept_garbage) ||
-      (options == base64_options::base64_default_accept_garbage) ||
-      (options == base64_options::base64_default_or_url_accept_garbage);
-
-  const char_type *srcend = src + length;
-  const char_type *srcinit = src;
-  const char *dstinit = dst;
-
-  uint32_t x;
-  size_t idx;
-  uint8_t buffer[4];
-  while (true) {
-    while (src + 4 <= srcend && is_eight_byte(src[0]) &&
-           is_eight_byte(src[1]) && is_eight_byte(src[2]) &&
-           is_eight_byte(src[3]) &&
-           (x = d0[uint8_t(src[0])] | d1[uint8_t(src[1])] |
-                d2[uint8_t(src[2])] | d3[uint8_t(src[3])]) < 0x01FFFFFF) {
-      if (match_system(endianness::BIG)) {
-        x = scalar::u32_swap_bytes(x);
-      }
-      if (check_capacity && dstend - dst < 3) {
-        return {OUTPUT_BUFFER_TOO_SMALL, size_t(src - srcinit),
-                size_t(dst - dstinit)};
-      }
-      std::memcpy(dst, &x, 3); // optimization opportunity: copy 4 bytes
-      dst += 3;
-      src += 4;
-    }
-    const char_type *srccur = src;
-    idx = 0;
-    // we need at least four characters.
-#ifdef __clang__
-    // If possible, we read four characters at a time. (It is an optimization.)
-    if (ignore_garbage && src + 4 <= srcend) {
-      char_type c0 = src[0];
-      char_type c1 = src[1];
-      char_type c2 = src[2];
-      char_type c3 = src[3];
-
-      uint8_t code0 = to_base64[uint8_t(c0)];
-      uint8_t code1 = to_base64[uint8_t(c1)];
-      uint8_t code2 = to_base64[uint8_t(c2)];
-      uint8_t code3 = to_base64[uint8_t(c3)];
-
-      buffer[idx] = code0;
-      idx += (is_eight_byte(c0) && code0 <= 63);
-      buffer[idx] = code1;
-      idx += (is_eight_byte(c1) && code1 <= 63);
-      buffer[idx] = code2;
-      idx += (is_eight_byte(c2) && code2 <= 63);
-      buffer[idx] = code3;
-      idx += (is_eight_byte(c3) && code3 <= 63);
-      src += 4;
-    }
-#endif
-    while ((idx < 4) && (src < srcend)) {
-      char_type c = *src;
-
-      uint8_t code = to_base64[uint8_t(c)];
-      buffer[idx] = uint8_t(code);
-      if (is_eight_byte(c) && code <= 63) {
-        idx++;
-      } else if (!ignore_garbage &&
-                 (code > 64 || !scalar::base64::is_eight_byte(c))) {
-        return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-                size_t(dst - dstinit)};
-      } else {
-        // We have a space or a newline or garbage. We ignore it.
-      }
-      src++;
-    }
-    if (idx != 4) {
-      simdutf_log_assert(idx < 4, "idx should be less than 4");
-      // We never should have that the number of base64 characters + the
-      // number of padding characters is more than 4.
-      if (!ignore_garbage && (idx + padding_characters > 4)) {
-        return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-                size_t(dst - dstinit), true};
-      }
-
-      // The idea here is that in loose mode,
-      // if there is padding at all, it must be used
-      // to form 4-wise chunk. However, in loose mode,
-      // we do accept no padding at all.
-      if (!ignore_garbage &&
-          last_chunk_options == last_chunk_handling_options::loose &&
-          (idx >= 2) && padding_characters > 0 &&
-          ((idx + padding_characters) & 3) != 0) {
-        return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-                size_t(dst - dstinit), true};
-      } else
-
-        // The idea here is that in strict mode, we do not want to accept
-        // incomplete base64 chunks. So if the chunk was otherwise valid, we
-        // return BASE64_INPUT_REMAINDER.
-        if (!ignore_garbage &&
-            last_chunk_options == last_chunk_handling_options::strict &&
-            (idx >= 2) && ((idx + padding_characters) & 3) != 0) {
-          // The partial chunk was at src - idx
-          return {BASE64_INPUT_REMAINDER, size_t(src - srcinit),
-                  size_t(dst - dstinit), true};
-        } else
-          // If there is a partial chunk with insufficient padding, with
-          // stop_before_partial, we need to just ignore it. In "only full"
-          // mode, skip the minute there are padding characters.
-          if ((last_chunk_options ==
-                   last_chunk_handling_options::stop_before_partial &&
-               (padding_characters + idx < 4) && (idx != 0) &&
-               (idx >= 2 || padding_characters == 0)) ||
-              (last_chunk_options ==
-                   last_chunk_handling_options::only_full_chunks &&
-               (idx >= 2 || padding_characters == 0))) {
-            // partial means that we are *not* going to consume the read
-            // characters. We need to rewind the src pointer.
-            src = srccur;
-            return {SUCCESS, size_t(src - srcinit), size_t(dst - dstinit)};
-          } else {
-            if (idx == 2) {
-              uint32_t triple = (uint32_t(buffer[0]) << 3 * 6) +
-                                (uint32_t(buffer[1]) << 2 * 6);
-              if (!ignore_garbage &&
-                  (last_chunk_options == last_chunk_handling_options::strict) &&
-                  (triple & 0xffff)) {
-                return {BASE64_EXTRA_BITS, size_t(src - srcinit),
-                        size_t(dst - dstinit)};
-              }
-              if (check_capacity && dstend - dst < 1) {
-                return {OUTPUT_BUFFER_TOO_SMALL, size_t(srccur - srcinit),
-                        size_t(dst - dstinit)};
-              }
-              if (match_system(endianness::BIG)) {
-                triple <<= 8;
-                std::memcpy(dst, &triple, 1);
-              } else {
-                triple = scalar::u32_swap_bytes(triple);
-                triple >>= 8;
-                std::memcpy(dst, &triple, 1);
-              }
-              dst += 1;
-            } else if (idx == 3) {
-              uint32_t triple = (uint32_t(buffer[0]) << 3 * 6) +
-                                (uint32_t(buffer[1]) << 2 * 6) +
-                                (uint32_t(buffer[2]) << 1 * 6);
-              if (!ignore_garbage &&
-                  (last_chunk_options == last_chunk_handling_options::strict) &&
-                  (triple & 0xff)) {
-                return {BASE64_EXTRA_BITS, size_t(src - srcinit),
-                        size_t(dst - dstinit)};
-              }
-              if (check_capacity && dstend - dst < 2) {
-                return {OUTPUT_BUFFER_TOO_SMALL, size_t(srccur - srcinit),
-                        size_t(dst - dstinit)};
-              }
-              if (match_system(endianness::BIG)) {
-                triple <<= 8;
-                std::memcpy(dst, &triple, 2);
-              } else {
-                triple = scalar::u32_swap_bytes(triple);
-                triple >>= 8;
-                std::memcpy(dst, &triple, 2);
-              }
-              dst += 2;
-            } else if (!ignore_garbage && idx == 1 &&
-                       (!is_partial(last_chunk_options) ||
-                        (is_partial(last_chunk_options) &&
-                         padding_characters > 0))) {
-              return {BASE64_INPUT_REMAINDER, size_t(src - srcinit),
-                      size_t(dst - dstinit)};
-            } else if (!ignore_garbage && idx == 0 && padding_characters > 0) {
-              return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-                      size_t(dst - dstinit), true};
-            }
-            return {SUCCESS, size_t(src - srcinit), size_t(dst - dstinit)};
-          }
-    }
-    if (check_capacity && dstend - dst < 3) {
-      return {OUTPUT_BUFFER_TOO_SMALL, size_t(srccur - srcinit),
-              size_t(dst - dstinit)};
-    }
-    uint32_t triple =
-        (uint32_t(buffer[0]) << 3 * 6) + (uint32_t(buffer[1]) << 2 * 6) +
-        (uint32_t(buffer[2]) << 1 * 6) + (uint32_t(buffer[3]) << 0 * 6);
-    if (match_system(endianness::BIG)) {
-      triple <<= 8;
-      std::memcpy(dst, &triple, 3);
-    } else {
-      triple = scalar::u32_swap_bytes(triple);
-      triple >>= 8;
-      std::memcpy(dst, &triple, 3);
-    }
-    dst += 3;
-  }
-}
-
-template <class char_type>
-full_result
-base64_tail_decode(char *dst, const char_type *src, size_t length,
-                   size_t padding_characters, // number of padding characters
-                                              // '=', typically 0, 1, 2.
-                   base64_options options,
-                   last_chunk_handling_options last_chunk_options) {
-  return base64_tail_decode_impl<false>(dst, 0, src, length, padding_characters,
-                                        options, last_chunk_options);
-}
-
-// like base64_tail_decode, but it will not write past the end of the output
-// buffer. The outlen parameter is modified to reflect the number of bytes
-// written. This functions assumes that the padding (=) has been removed.
-//
-template <class char_type>
-full_result base64_tail_decode_safe(
-    char *dst, size_t outlen, const char_type *src, size_t length,
-    size_t padding_characters, // number of padding characters
-                               // '=', typically 0, 1, 2.
-    base64_options options, last_chunk_handling_options last_chunk_options) {
-  return base64_tail_decode_impl<true>(dst, outlen, src, length,
-                                       padding_characters, options,
-                                       last_chunk_options);
-}
-
-inline full_result
-patch_tail_result(full_result r, size_t previous_input, size_t previous_output,
-                  size_t equallocation, size_t full_input_length,
-                  last_chunk_handling_options last_chunk_options) {
-  r.input_count += previous_input;
-  r.output_count += previous_output;
-  if (r.padding_error) {
-    r.input_count = equallocation;
-  }
-
-  if (r.error == error_code::SUCCESS) {
-    if (!is_partial(last_chunk_options)) {
-      // A success when we are not in stop_before_partial mode.
-      // means that we have consumed the whole input buffer.
-      r.input_count = full_input_length;
-    } else if (r.output_count % 3 != 0) {
-      r.input_count = full_input_length;
-    }
-  }
-  return r;
-}
-
-// Returns the number of bytes written. The destination buffer must be large
-// enough. It will add padding (=) if needed.
-size_t tail_encode_base64(char *dst, const char *src, size_t srclen,
-                          base64_options options) {
-  // By default, we use padding if we are not using the URL variant.
-  // This is check with ((options & base64_url) == 0) which returns true if we
-  // are not using the URL variant. However, we also allow 'inversion' of the
-  // convention with the base64_reverse_padding option. If the
-  // base64_reverse_padding option is set, we use padding if we are using the
-  // URL variant, and we omit it if we are not using the URL variant. This is
-  // checked with
-  // ((options & base64_reverse_padding) == base64_reverse_padding).
-  bool use_padding =
-      ((options & base64_url) == 0) ^
-      ((options & base64_reverse_padding) == base64_reverse_padding);
-  // This looks like 3 branches, but we expect the compiler to resolve this to
-  // a single branch:
-  const char *e0 = (options & base64_url) ? tables::base64::base64_url::e0
-                                          : tables::base64::base64_default::e0;
-  const char *e1 = (options & base64_url) ? tables::base64::base64_url::e1
-                                          : tables::base64::base64_default::e1;
-  const char *e2 = (options & base64_url) ? tables::base64::base64_url::e2
-                                          : tables::base64::base64_default::e2;
-  char *out = dst;
-  size_t i = 0;
-  uint8_t t1, t2, t3;
-  for (; i + 2 < srclen; i += 3) {
-    t1 = uint8_t(src[i]);
-    t2 = uint8_t(src[i + 1]);
-    t3 = uint8_t(src[i + 2]);
-    *out++ = e0[t1];
-    *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
-    *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
-    *out++ = e2[t3];
-  }
-  switch (srclen - i) {
-  case 0:
-    break;
-  case 1:
-    t1 = uint8_t(src[i]);
-    *out++ = e0[t1];
-    *out++ = e1[(t1 & 0x03) << 4];
-    if (use_padding) {
-      *out++ = '=';
-      *out++ = '=';
-    }
-    break;
-  default: /* case 2 */
-    t1 = uint8_t(src[i]);
-    t2 = uint8_t(src[i + 1]);
-    *out++ = e0[t1];
-    *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
-    *out++ = e2[(t2 & 0x0F) << 2];
-    if (use_padding) {
-      *out++ = '=';
-    }
-  }
-  return (size_t)(out - dst);
-}
-
-template <class char_type>
-simdutf_warn_unused size_t maximal_binary_length_from_base64(
-    const char_type *input, size_t length) noexcept {
-  // We follow https://infra.spec.whatwg.org/#forgiving-base64-decode
-  size_t padding = 0;
-  if (length > 0) {
-    if (input[length - 1] == '=') {
-      padding++;
-      if (length > 1 && input[length - 2] == '=') {
-        padding++;
-      }
-    }
-  }
-  size_t actual_length = length - padding;
-  if (actual_length % 4 <= 1) {
-    return actual_length / 4 * 3;
-  }
-  // if we have a valid input, then the remainder must be 2 or 3 adding one or
-  // two extra bytes.
-  return actual_length / 4 * 3 + (actual_length % 4) - 1;
-}
-
-template <typename char_type>
-simdutf_warn_unused full_result base64_to_binary_details_impl(
-    const char_type *input, size_t length, char *output, base64_options options,
-    last_chunk_handling_options last_chunk_options) noexcept {
-  const bool ignore_garbage =
-      (options == base64_options::base64_url_accept_garbage) ||
-      (options == base64_options::base64_default_accept_garbage) ||
-      (options == base64_options::base64_default_or_url_accept_garbage);
-  auto ri = simdutf::scalar::base64::find_end(input, length, options);
-  size_t equallocation = ri.equallocation;
-  size_t equalsigns = ri.equalsigns;
-  length = ri.srclen;
-  size_t full_input_length = ri.full_input_length;
-  if (length == 0) {
-    if (!ignore_garbage && equalsigns > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation, 0};
-    }
-    return {SUCCESS, full_input_length, 0};
-  }
-  full_result r = scalar::base64::base64_tail_decode(
-      output, input, length, equalsigns, options, last_chunk_options);
-  r = scalar::base64::patch_tail_result(r, 0, 0, equallocation,
-                                        full_input_length, last_chunk_options);
-  if (!is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
-      equalsigns > 0 && !ignore_garbage) {
-    // additional checks
-    if ((r.output_count % 3 == 0) ||
-        ((r.output_count % 3) + 1 + equalsigns != 4)) {
-      return {INVALID_BASE64_CHARACTER, equallocation, r.output_count};
-    }
-  }
-  // When is_partial(last_chunk_options) is true, we must either end with
-  // the end of the stream (beyond whitespace) or right after a non-ignorable
-  // character or at the very beginning of the stream.
-  // See https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
-  if (is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
-      r.input_count < full_input_length) {
-    // First check if we can extend the input to the end of the stream
-    while (r.input_count < full_input_length &&
-           base64_ignorable(*(input + r.input_count), options)) {
-      r.input_count++;
-    }
-    // If we are still not at the end of the stream, then we must backtrack
-    // to the last non-ignorable character.
-    if (r.input_count < full_input_length) {
-      while (r.input_count > 0 &&
-             base64_ignorable(*(input + r.input_count - 1), options)) {
-        r.input_count--;
-      }
-    }
-  }
-  return r;
-}
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused result base64_to_binary(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
+  simdutf_warn_unused full_result base64_to_binary_details(
+      const char16_t *input, size_t length, char *output,
+      base64_options options,
+      last_chunk_handling_options last_chunk_options =
+          last_chunk_handling_options::loose) const noexcept override;
+  size_t binary_to_base64(const char *input, size_t length, char *output,
+                          base64_options options) const noexcept override;
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override;
+  const char *find(const char *start, const char *end,
+                   char character) const noexcept override;
+  const char16_t *find(const char16_t *start, const char16_t *end,
+                       char16_t character) const noexcept override;
 
-template <typename char_type>
-simdutf_warn_unused full_result base64_to_binary_details_safe_impl(
-    const char_type *input, size_t length, char *output, size_t outlen,
-    base64_options options,
-    last_chunk_handling_options last_chunk_options) noexcept {
-  const bool ignore_garbage =
-      (options == base64_options::base64_url_accept_garbage) ||
-      (options == base64_options::base64_default_accept_garbage) ||
-      (options == base64_options::base64_default_or_url_accept_garbage);
-  auto ri = simdutf::scalar::base64::find_end(input, length, options);
-  size_t equallocation = ri.equallocation;
-  size_t equalsigns = ri.equalsigns;
-  length = ri.srclen;
-  size_t full_input_length = ri.full_input_length;
-  if (length == 0) {
-    if (!ignore_garbage && equalsigns > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation, 0};
-    }
-    return {SUCCESS, full_input_length, 0};
-  }
-  full_result r = scalar::base64::base64_tail_decode_safe(
-      output, outlen, input, length, equalsigns, options, last_chunk_options);
-  r = scalar::base64::patch_tail_result(r, 0, 0, equallocation,
-                                        full_input_length, last_chunk_options);
-  if (!is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
-      equalsigns > 0 && !ignore_garbage) {
-    // additional checks
-    if ((r.output_count % 3 == 0) ||
-        ((r.output_count % 3) + 1 + equalsigns != 4)) {
-      return {INVALID_BASE64_CHARACTER, equallocation, r.output_count};
-    }
-  }
+};
+} // namespace fallback
+} // namespace simdutf
 
-  // When is_partial(last_chunk_options) is true, we must either end with
-  // the end of the stream (beyond whitespace) or right after a non-ignorable
-  // character or at the very beginning of the stream.
-  // See https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
-  if (is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
-      r.input_count < full_input_length) {
-    // First check if we can extend the input to the end of the stream
-    while (r.input_count < full_input_length &&
-           base64_ignorable(*(input + r.input_count), options)) {
-      r.input_count++;
-    }
-    // If we are still not at the end of the stream, then we must backtrack
-    // to the last non-ignorable character.
-    if (r.input_count < full_input_length) {
-      while (r.input_count > 0 &&
-             base64_ignorable(*(input + r.input_count - 1), options)) {
-        r.input_count--;
-      }
-    }
-  }
-  return r;
-}
+#endif // SIMDUTF_FALLBACK_IMPLEMENTATION_H
+/* end file src/simdutf/fallback/implementation.h */
 
-simdutf_warn_unused size_t
-base64_length_from_binary(size_t length, base64_options options) noexcept {
-  // By default, we use padding if we are not using the URL variant.
-  // This is check with ((options & base64_url) == 0) which returns true if we
-  // are not using the URL variant. However, we also allow 'inversion' of the
-  // convention with the base64_reverse_padding option. If the
-  // base64_reverse_padding option is set, we use padding if we are using the
-  // URL variant, and we omit it if we are not using the URL variant. This is
-  // checked with
-  // ((options & base64_reverse_padding) == base64_reverse_padding).
-  bool use_padding =
-      ((options & base64_url) == 0) ^
-      ((options & base64_reverse_padding) == base64_reverse_padding);
-  if (!use_padding) {
-    return length / 3 * 4 + ((length % 3) ? (length % 3) + 1 : 0);
-  }
-  return (length + 2) / 3 *
-         4; // We use padding to make the length a multiple of 4.
-}
-
-// Return the length of the prefix that contains count base64 characters.
-// Thus, if count is 3, the function returns the length of the prefix
-// that contains 3 base64 characters.
-// The function returns (size_t)-1 if there is not enough base64 characters in
-// the input.
-template <typename char_type>
-simdutf_warn_unused size_t prefix_length(size_t count,
-                                         simdutf::base64_options options,
-                                         const char_type *input,
-                                         size_t length) noexcept {
-  size_t i = 0;
-  while (i < length && is_ignorable(input[i], options)) {
-    i++;
-  }
-  if (count == 0) {
-    return i; // duh!
-  }
-  for (; i < length; i++) {
-    if (is_ignorable(input[i], options)) {
-      continue;
-    }
-    // We have a base64 character or a padding character.
-    count--;
-    if (count == 0) {
-      return i + 1;
-    }
-  }
-  simdutf_log_assert(false, "You never get here");
+/* begin file src/simdutf/fallback/begin.h */
+// redefining SIMDUTF_IMPLEMENTATION to "fallback"
+// #define SIMDUTF_IMPLEMENTATION fallback
+/* end file src/simdutf/fallback/begin.h */
 
-  return -1; // should never happen
-}
+  // Declarations
+/* begin file src/simdutf/fallback/bitmanipulation.h */
+#ifndef SIMDUTF_FALLBACK_BITMANIPULATION_H
+#define SIMDUTF_FALLBACK_BITMANIPULATION_H
 
-} // namespace base64
-} // unnamed namespace
-} // namespace scalar
+#include <limits>
+
+namespace simdutf {
+namespace fallback {
+namespace {} // unnamed namespace
+} // namespace fallback
 } // namespace simdutf
 
+#endif // SIMDUTF_FALLBACK_BITMANIPULATION_H
+/* end file src/simdutf/fallback/bitmanipulation.h */
+
+/* begin file src/simdutf/fallback/end.h */
+/* end file src/simdutf/fallback/end.h */
+
+#endif // SIMDUTF_IMPLEMENTATION_FALLBACK
+#endif // SIMDUTF_FALLBACK_H
+/* end file src/simdutf/fallback.h */
+#ifndef SIMDUTF_REGULAR_VISUAL_STUDIO
+SIMDUTF_POP_DISABLE_WARNINGS
 #endif
-/* end file src/scalar/base64.h */
+
+// The scalar routines should be included once.
 
 /* begin file src/implementation.cpp */
-#include <initializer_list>
+#include <algorithm>
 #include <climits>
 #include <type_traits>
+#include <utility>
 #if SIMDUTF_ATOMIC_REF
-/* begin file src/scalar/atomic_util.h */
-#ifndef SIMDUTF_ATOMIC_UTIL_H
-#define SIMDUTF_ATOMIC_UTIL_H
-#if SIMDUTF_ATOMIC_REF
-  #include <atomic>
-namespace simdutf {
-namespace scalar {
-
-// This function is a memcpy that uses atomic operations to read from the
-// source.
-inline void memcpy_atomic_read(char *dst, const char *src, size_t len) {
-  static_assert(std::atomic_ref<char>::required_alignment == sizeof(char),
-                "std::atomic_ref requires the same alignment as char_type");
-  // We expect all 64-bit systems to be able to read 64-bit words from an
-  // aligned memory region atomically. You might be able to do better on
-  // specific systems, e.g., x64 systems can read 128-bit words atomically.
-  constexpr size_t alignment = sizeof(uint64_t);
-
-  // Lambda for atomic byte-by-byte copy
-  auto bbb_memcpy_atomic_read = [](char *bytedst, const char *bytesrc,
-                                   size_t bytelen) noexcept {
-    char *mutable_src = const_cast<char *>(bytesrc);
-    for (size_t j = 0; j < bytelen; ++j) {
-      bytedst[j] =
-          std::atomic_ref<char>(mutable_src[j]).load(std::memory_order_relaxed);
-    }
-  };
-
-  // Handle unaligned start
-  size_t offset = reinterpret_cast<std::uintptr_t>(src) % alignment;
-  if (offset) {
-    size_t to_align = std::min(len, alignment - offset);
-    bbb_memcpy_atomic_read(dst, src, to_align);
-    src += to_align;
-    dst += to_align;
-    len -= to_align;
-  }
-
-  // Process aligned 64-bit chunks
-  while (len >= alignment) {
-    auto *src_aligned = reinterpret_cast<uint64_t *>(const_cast<char *>(src));
-    const auto dst_value =
-        std::atomic_ref<uint64_t>(*src_aligned).load(std::memory_order_relaxed);
-    std::memcpy(dst, &dst_value, sizeof(uint64_t));
-    src += alignment;
-    dst += alignment;
-    len -= alignment;
-  }
-
-  // Handle remaining bytes
-  if (len) {
-    bbb_memcpy_atomic_read(dst, src, len);
-  }
-}
-
-// This function is a memcpy that uses atomic operations to write to the
-// destination.
-inline void memcpy_atomic_write(char *dst, const char *src, size_t len) {
-  static_assert(std::atomic_ref<char>::required_alignment == sizeof(char),
-                "std::atomic_ref requires the same alignment as char");
-  // We expect all 64-bit systems to be able to write 64-bit words to an aligned
-  // memory region atomically.
-  // You might be able to do better on specific systems, e.g., x64 systems can
-  // write 128-bit words atomically.
-  constexpr size_t alignment = sizeof(uint64_t);
-
-  // Lambda for atomic byte-by-byte write
-  auto bbb_memcpy_atomic_write = [](char *bytedst, const char *bytesrc,
-                                    size_t bytelen) noexcept {
-    for (size_t j = 0; j < bytelen; ++j) {
-      std::atomic_ref<char>(bytedst[j])
-          .store(bytesrc[j], std::memory_order_relaxed);
-    }
-  };
-
-  // Handle unaligned start
-  size_t offset = reinterpret_cast<std::uintptr_t>(dst) % alignment;
-  if (offset) {
-    size_t to_align = std::min(len, alignment - offset);
-    bbb_memcpy_atomic_write(dst, src, to_align);
-    dst += to_align;
-    src += to_align;
-    len -= to_align;
-  }
-
-  // Process aligned 64-bit chunks
-  while (len >= alignment) {
-    auto *dst_aligned = reinterpret_cast<uint64_t *>(dst);
-    uint64_t src_val;
-    std::memcpy(&src_val, src, sizeof(uint64_t)); // Non-atomic read from src
-    std::atomic_ref<uint64_t>(*dst_aligned)
-        .store(src_val, std::memory_order_relaxed);
-    dst += alignment;
-    src += alignment;
-    len -= alignment;
-  }
+  #include <array>
+#endif
 
-  // Handle remaining bytes
-  if (len) {
-    bbb_memcpy_atomic_write(dst, src, len);
-  }
-}
-} // namespace scalar
-} // namespace simdutf
-#endif // SIMDUTF_ATOMIC_REF
-#endif // SIMDUTF_ATOMIC_UTIL_H
-/* end file src/scalar/atomic_util.h */
+// The macro SIMDUTF_USE_STATIC_INITIALIZATION, when set to 1, means that we
+// will use translation-unit-scope variables to hold our implementations.
+//
+// The downside of a translation-unit-scope variable is that the initialization
+// order is not well defined, thus if someone uses simdutf before main() starts,
+// they might get a crash. Thus setting SIMDUTF_USE_STATIC_INITIALIZATION to 1
+// is not recommended if you are using simdutf in a library that might be used
+// by other code before main() starts. However, the upside is that there is no
+// synchronization overhead on every call to get_active_implementation(). When
+// compiling without the c++ standard library, we use static initialization,
+// because C++ relies on the standard library for thread-safe initialization of
+// function-scope static variables.
+//
+// By default, we avoid translation-unit-scope static initialization, so we set
+// SIMDUTF_USE_STATIC_INITIALIZATION to 0. It comes with a small performance
+// cost on the first call to get_active_implementation(), and a smaller cost on
+// subsequent calls but it is then safe to use the simdutf library in static
+// initialization.
+//
+// Further reading: https://en.cppreference.com/cpp/language/siof
+#ifndef SIMDUTF_USE_STATIC_INITIALIZATION
+  #if SIMDUTF_NO_LIBCXX
+    #define SIMDUTF_USE_STATIC_INITIALIZATION 1
+  #else // SIMDUTF_NO_LIBCXX
+    #define SIMDUTF_USE_STATIC_INITIALIZATION 0
+  #endif // SIMDUTF_NO_LIBCXX
+#endif   // SIMDUTF_USE_STATIC_INITIALIZATION
+
+// When building without libc++abi (SIMDUTF_NO_LIBCXX=1) on GCC/Clang, provide
+// a weak stub for __cxa_pure_virtual so the abstract implementation vtable
+// does not drag in libc++abi just for this unreachable hook. Kept weak so a
+// real libc++abi definition wins if one is linked in anyway.
+#if SIMDUTF_NO_LIBCXX
+extern "C" __attribute__((weak, noreturn)) void __cxa_pure_virtual() {
+  __builtin_trap();
+}
+namespace std {
+__attribute__((weak, noreturn)) void
+__glibcxx_assert_fail(const char *, int, const char *, const char *) noexcept {
+  __builtin_trap();
+}
+} // namespace std
 #endif
 
 static_assert(sizeof(uint8_t) == sizeof(char),
@@ -11514,22 +10023,6 @@ static_assert(sizeof(uint32_t) == sizeof(char32_t),
 // next line is redundant, but it is kept to catch defective systems.
 static_assert(CHAR_BIT == 8, "simdutf requires 8-bit bytes");
 
-// Useful for debugging purposes
-namespace simdutf {
-namespace {
-
-template <typename T> std::string toBinaryString(T b) {
-  std::string binary = "";
-  T mask = T(1) << (sizeof(T) * CHAR_BIT - 1);
-  while (mask > 0) {
-    binary += ((b & mask) == 0) ? '0' : '1';
-    mask >>= 1;
-  }
-  return binary;
-}
-} // namespace
-} // namespace simdutf
-
 namespace simdutf {
 bool implementation::supported_by_runtime_system() const {
   uint32_t required_instruction_sets = this->required_instruction_sets();
@@ -11549,6 +10042,16 @@ simdutf_warn_unused size_t implementation::maximal_binary_length_from_base64(
   return scalar::base64::maximal_binary_length_from_base64(input, length);
 }
 
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return scalar::base64::binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return scalar::base64::binary_length_from_base64(input, length);
+}
+
 simdutf_warn_unused size_t implementation::base64_length_from_binary(
     size_t length, base64_options options) const noexcept {
   return scalar::base64::base64_length_from_binary(length, options);
@@ -11565,66 +10068,108 @@ namespace internal {
        SIMDUTF_IMPLEMENTATION_LASX + SIMDUTF_IMPLEMENTATION_FALLBACK ==        \
    1)
 
-// Static array of known implementations. We are hoping these get baked into the
-// executable without requiring a static initializer.
-
 #if SIMDUTF_IMPLEMENTATION_ICELAKE
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const icelake::implementation icelake_singleton{};
+  #endif
 static const icelake::implementation *get_icelake_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const icelake::implementation icelake_singleton{};
+  #endif
   return &icelake_singleton;
 }
 #endif
 #if SIMDUTF_IMPLEMENTATION_HASWELL
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const haswell::implementation haswell_singleton{};
+  #endif
 static const haswell::implementation *get_haswell_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const haswell::implementation haswell_singleton{};
+  #endif
   return &haswell_singleton;
 }
 #endif
 #if SIMDUTF_IMPLEMENTATION_WESTMERE
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const westmere::implementation westmere_singleton{};
+  #endif
 static const westmere::implementation *get_westmere_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const westmere::implementation westmere_singleton{};
+  #endif
   return &westmere_singleton;
 }
 #endif
 #if SIMDUTF_IMPLEMENTATION_ARM64
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const arm64::implementation arm64_singleton{};
+  #endif
 static const arm64::implementation *get_arm64_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const arm64::implementation arm64_singleton{};
+  #endif
   return &arm64_singleton;
 }
 #endif
 #if SIMDUTF_IMPLEMENTATION_PPC64
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const ppc64::implementation ppc64_singleton{};
+  #endif
 static const ppc64::implementation *get_ppc64_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const ppc64::implementation ppc64_singleton{};
+  #endif
   return &ppc64_singleton;
 }
 #endif
 #if SIMDUTF_IMPLEMENTATION_RVV
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const rvv::implementation rvv_singleton{};
+  #endif
 static const rvv::implementation *get_rvv_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const rvv::implementation rvv_singleton{};
+  #endif
   return &rvv_singleton;
 }
 #endif
-#if SIMDUTF_IMPLEMENTATION_LSX
-static const lsx::implementation *get_lsx_singleton() {
-  static const lsx::implementation lsx_singleton{};
-  return &lsx_singleton;
-}
-#endif
 #if SIMDUTF_IMPLEMENTATION_LASX
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const lasx::implementation lasx_singleton{};
+  #endif
 static const lasx::implementation *get_lasx_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const lasx::implementation lasx_singleton{};
+  #endif
   return &lasx_singleton;
 }
 #endif
+#if SIMDUTF_IMPLEMENTATION_LSX
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const lsx::implementation lsx_singleton{};
+  #endif
+static const lsx::implementation *get_lsx_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
+  static const lsx::implementation lsx_singleton{};
+  #endif
+  return &lsx_singleton;
+}
+#endif
 #if SIMDUTF_IMPLEMENTATION_FALLBACK
+  #if SIMDUTF_USE_STATIC_INITIALIZATION
+static const fallback::implementation fallback_singleton{};
+  #endif
 static const fallback::implementation *get_fallback_singleton() {
+  #if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const fallback::implementation fallback_singleton{};
+  #endif
   return &fallback_singleton;
 }
 #endif
 
 #if SIMDUTF_SINGLE_IMPLEMENTATION
-static const implementation *get_single_implementation() {
+simdutf_really_inline static const implementation *get_single_implementation() {
   return
   #if SIMDUTF_IMPLEMENTATION_ICELAKE
       get_icelake_singleton();
@@ -11641,12 +10186,12 @@ static const implementation *get_single_implementation() {
   #if SIMDUTF_IMPLEMENTATION_PPC64
   get_ppc64_singleton();
   #endif
-  #if SIMDUTF_IMPLEMENTATION_LSX
-  get_lsx_singleton();
-  #endif
   #if SIMDUTF_IMPLEMENTATION_LASX
   get_lasx_singleton();
   #endif
+  #if SIMDUTF_IMPLEMENTATION_LSX
+  get_lsx_singleton();
+  #endif
   #if SIMDUTF_IMPLEMENTATION_FALLBACK
   get_fallback_singleton();
   #endif
@@ -11659,8 +10204,8 @@ static const implementation *get_single_implementation() {
 class detect_best_supported_implementation_on_first_use final
     : public implementation {
 public:
-  std::string name() const noexcept final { return set_best()->name(); }
-  std::string description() const noexcept final {
+  std::string_view name() const noexcept final { return set_best()->name(); }
+  std::string_view description() const noexcept final {
     return set_best()->description();
   }
   uint32_t required_instruction_sets() const noexcept final {
@@ -11706,6 +10251,14 @@ class detect_best_supported_implementation_on_first_use final
     return set_best()->binary_to_base64(input, length, output, options);
   }
 
+  size_t
+  binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                              size_t line_length,
+                              base64_options options) const noexcept override {
+    return set_best()->binary_to_base64_with_lines(input, length, output,
+                                                   line_length, options);
+  }
+
   const char *find(const char *start, const char *end,
                    char character) const noexcept override {
     return set_best()->find(start, end, character);
@@ -11716,6 +10269,16 @@ class detect_best_supported_implementation_on_first_use final
     return set_best()->find(start, end, character);
   }
 
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char *input, size_t length) const noexcept override {
+    return set_best()->binary_length_from_base64(input, length);
+  }
+
+  simdutf_warn_unused size_t binary_length_from_base64(
+      const char16_t *input, size_t length) const noexcept override {
+    return set_best()->binary_length_from_base64(input, length);
+  }
+
   simdutf_really_inline
   detect_best_supported_implementation_on_first_use() noexcept
       : implementation("best_supported_detector",
@@ -11731,38 +10294,72 @@ static_assert(std::is_trivially_destructible<
               "detect_best_supported_implementation_on_first_use should be "
               "trivially destructible");
 
+#if SIMDUTF_USE_STATIC_INITIALIZATION
+static const std::initializer_list<const implementation *>
+    available_implementation_pointers{
+  #if SIMDUTF_IMPLEMENTATION_ICELAKE
+        get_icelake_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_HASWELL
+        get_haswell_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_WESTMERE
+        get_westmere_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_ARM64
+        get_arm64_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_PPC64
+        get_ppc64_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_RVV
+        get_rvv_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_LASX
+        get_lasx_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_LSX
+        get_lsx_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_FALLBACK
+        get_fallback_singleton(),
+  #endif
+    };
+#endif
 static const std::initializer_list<const implementation *> &
 get_available_implementation_pointers() {
+#if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const std::initializer_list<const implementation *>
       available_implementation_pointers{
-#if SIMDUTF_IMPLEMENTATION_ICELAKE
+  #if SIMDUTF_IMPLEMENTATION_ICELAKE
           get_icelake_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_HASWELL
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_HASWELL
           get_haswell_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_WESTMERE
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_WESTMERE
           get_westmere_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_ARM64
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_ARM64
           get_arm64_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_PPC64
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_PPC64
           get_ppc64_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_RVV
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_RVV
           get_rvv_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_LSX
-          get_lsx_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_LASX
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_LASX
           get_lasx_singleton(),
-#endif
-#if SIMDUTF_IMPLEMENTATION_FALLBACK
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_LSX
+          get_lsx_singleton(),
+  #endif
+  #if SIMDUTF_IMPLEMENTATION_FALLBACK
           get_fallback_singleton(),
+  #endif
+      };
 #endif
-      }; // available_implementation_pointers
   return available_implementation_pointers;
 }
 
@@ -11799,6 +10396,10 @@ class unsupported_implementation final : public implementation {
                           base64_options) const noexcept override {
     return 0;
   }
+  size_t binary_to_base64_with_lines(const char *, size_t, char *, size_t,
+                                     base64_options) const noexcept override {
+    return 0;
+  }
   const char *find(const char *, const char *, char) const noexcept override {
     return nullptr;
   }
@@ -11806,14 +10407,27 @@ class unsupported_implementation final : public implementation {
                        char16_t) const noexcept override {
     return nullptr;
   }
+  simdutf_warn_unused size_t
+  binary_length_from_base64(const char *, size_t) const noexcept override {
+    return 0;
+  }
+  simdutf_warn_unused size_t
+  binary_length_from_base64(const char16_t *, size_t) const noexcept override {
+    return 0;
+  }
 
   unsupported_implementation()
       : implementation("unsupported",
                        "Unsupported CPU (no detected SIMD instructions)", 0) {}
 };
 
+#if SIMDUTF_USE_STATIC_INITIALIZATION
+static const unsupported_implementation unsupported_singleton{};
+#endif
 const unsupported_implementation *get_unsupported_singleton() {
+#if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const unsupported_implementation unsupported_singleton{};
+#endif
   return &unsupported_singleton;
 }
 static_assert(std::is_trivially_destructible<unsupported_implementation>::value,
@@ -11873,49 +10487,174 @@ detect_best_supported_implementation_on_first_use::set_best() const noexcept {
 /**
  * The list of available implementations compiled into simdutf.
  */
+#if SIMDUTF_USE_STATIC_INITIALIZATION
+static const internal::available_implementation_list
+    available_implementations_instance{};
+#endif
 SIMDUTF_DLLIMPORTEXPORT const internal::available_implementation_list &
 get_available_implementations() {
+#if !SIMDUTF_USE_STATIC_INITIALIZATION
   static const internal::available_implementation_list
-      available_implementations{};
-  return available_implementations;
+      available_implementations_instance{};
+#endif
+  return available_implementations_instance;
 }
 
+#if SIMDUTF_USE_STATIC_INITIALIZATION && !SIMDUTF_SINGLE_IMPLEMENTATION
+static const internal::detect_best_supported_implementation_on_first_use
+    detect_best_supported_implementation_on_first_use_singleton;
+#endif
+
+#if SIMDUTF_USE_STATIC_INITIALIZATION
+static internal::atomic_ptr<const implementation>
+    active_implementation_instance{
+  #if SIMDUTF_SINGLE_IMPLEMENTATION
+        internal::get_single_implementation()
+  #else
+        &detect_best_supported_implementation_on_first_use_singleton
+  #endif
+    };
+#endif
+
 /**
  * The active implementation.
  */
 SIMDUTF_DLLIMPORTEXPORT internal::atomic_ptr<const implementation> &
 get_active_implementation() {
-#if SIMDUTF_SINGLE_IMPLEMENTATION
-  // skip runtime detection
-  static internal::atomic_ptr<const implementation> active_implementation{
-      internal::get_single_implementation()};
-  return active_implementation;
-#else
+#if !SIMDUTF_USE_STATIC_INITIALIZATION
+  #if !SIMDUTF_SINGLE_IMPLEMENTATION
   static const internal::detect_best_supported_implementation_on_first_use
       detect_best_supported_implementation_on_first_use_singleton;
-  static internal::atomic_ptr<const implementation> active_implementation{
-      &detect_best_supported_implementation_on_first_use_singleton};
-  return active_implementation;
+  #endif
+  static internal::atomic_ptr<const implementation>
+      active_implementation_instance{
+  #if SIMDUTF_SINGLE_IMPLEMENTATION
+          internal::get_single_implementation()
+  #else
+          &detect_best_supported_implementation_on_first_use_singleton
+  #endif
+      };
 #endif
+  return active_implementation_instance;
 }
 
 #if SIMDUTF_SINGLE_IMPLEMENTATION
-const implementation *get_default_implementation() {
+simdutf_really_inline const implementation *get_default_implementation() {
   return internal::get_single_implementation();
 }
 #else
-internal::atomic_ptr<const implementation> &get_default_implementation() {
+simdutf_really_inline internal::atomic_ptr<const implementation> &
+get_default_implementation() {
   return get_active_implementation();
 }
 #endif
-#define SIMDUTF_GET_CURRENT_IMPLEMENTION
+#define SIMDUTF_GET_CURRENT_IMPLEMENTATION
+
+  #if SIMDUTF_ATOMIC_REF
+template <typename char_type>
+simdutf_warn_unused result atomic_base64_to_binary_safe_impl(
+    const char_type *input, size_t length, char *output, size_t &outlen,
+    base64_options options,
+    last_chunk_handling_options last_chunk_handling_options,
+    bool decode_up_to_bad_char) noexcept {
+    #if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
+  // We use a smaller buffer during fuzzing to more easily detect bugs.
+  constexpr size_t buffer_size = 128;
+    #else
+  // Arbitrary block sizes: 4KB for input.
+  constexpr size_t buffer_size = 4096;
+    #endif
+  std::array<char, buffer_size> temp_buffer;
+  const char_type *const input_init = input;
+  size_t actual_out = 0;
+  bool last_chunk = false;
+  const size_t length_init = length;
+  result r;
+  while (!last_chunk) {
+    last_chunk |= (temp_buffer.size() >= outlen - actual_out);
+    size_t temp_outlen = (std::min)(temp_buffer.size(), outlen - actual_out);
+    r = base64_to_binary_safe(input, length, temp_buffer.data(), temp_outlen,
+                              options, last_chunk_handling_options,
+                              decode_up_to_bad_char);
+    // We processed r.count characters of input.
+    // We wrote temp_outlen bytes to temp_buffer.
+    // If there is no ignorable characters,
+    // we should expect that values/4.0*3 == temp_outlen,
+    // except maybe at the tail end of the string.
+
+    //
+    // We are assuming that when r.error == error_code::OUTPUT_BUFFER_TOO_SMALL,
+    // we truncate the results so that a number of base64 characters divisible
+    // by four is processed.
+    //
+
+    //
+    // We wrote temp_outlen bytes to temp_buffer.
+    // We need to copy them to output.
+    // Copy with relaxed atomic operations to the output
+    simdutf_log_assert(temp_outlen <= outlen - actual_out,
+                       "Output buffer is too small");
+    simdutf_log_assert(temp_outlen <= temp_buffer.size(),
+                       "Output buffer is too small");
+
+    simdutf::scalar::memcpy_atomic_write(output + actual_out,
+                                         temp_buffer.data(), temp_outlen);
+    actual_out += temp_outlen;
+    length -= r.count;
+    input += r.count;
+
+    if (r.error != error_code::OUTPUT_BUFFER_TOO_SMALL) {
+      break;
+    }
+  }
+  if (size_t(input - input_init) != length_init) {
+    // We did not process all input characters. In such case, we
+    // should not end with an ignorable character. See
+    // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
+    while (input > input_init && base64_ignorable(*(input - 1), options)) {
+      --input;
+    }
+  }
+  outlen = actual_out;
+  return {r.error, size_t(input - input_init)};
+}
+
+simdutf_warn_unused result atomic_base64_to_binary_safe(
+    const char *input, size_t length, char *output, size_t &outlen,
+    base64_options options,
+    last_chunk_handling_options last_chunk_handling_options,
+    bool decode_up_to_bad_char) noexcept {
+  return atomic_base64_to_binary_safe_impl<char>(
+      input, length, output, outlen, options, last_chunk_handling_options,
+      decode_up_to_bad_char);
+}
+simdutf_warn_unused result atomic_base64_to_binary_safe(
+    const char16_t *input, size_t length, char *output, size_t &outlen,
+    base64_options options,
+    last_chunk_handling_options last_chunk_handling_options,
+    bool decode_up_to_bad_char) noexcept {
+  return atomic_base64_to_binary_safe_impl<char16_t>(
+      input, length, output, outlen, options, last_chunk_handling_options,
+      decode_up_to_bad_char);
+}
+  #endif // SIMDUTF_ATOMIC_REF
 
-simdutf_warn_unused const char *find(const char *start, const char *end,
-                                     char character) noexcept {
+// this has been moved to implementation.h
+// simdutf_warn_unused size_t
+// base64_length_from_binary(size_t length, base64_options option) noexcept;
+
+// this has been moved to implementation.h
+// simdutf_warn_unused size_t base64_length_from_binary_with_lines(
+//     size_t length, base64_options options, size_t line_length) noexcept;
+// }
+
+simdutf_warn_unused const char *detail::find(const char *start, const char *end,
+                                             char character) noexcept {
   return get_default_implementation()->find(start, end, character);
 }
-simdutf_warn_unused const char16_t *
-find(const char16_t *start, const char16_t *end, char16_t character) noexcept {
+simdutf_warn_unused const char16_t *detail::find(const char16_t *start,
+                                                 const char16_t *end,
+                                                 char16_t character) noexcept {
   return get_default_implementation()->find(start, end, character);
 }
 
@@ -11938,6 +10677,16 @@ simdutf_warn_unused size_t maximal_binary_length_from_base64(
       input, length);
 }
 
+simdutf_warn_unused size_t binary_length_from_base64(const char *input,
+                                                     size_t length) noexcept {
+  return get_default_implementation()->binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t binary_length_from_base64(const char16_t *input,
+                                                     size_t length) noexcept {
+  return get_default_implementation()->binary_length_from_base64(input, length);
+}
+
 simdutf_warn_unused result base64_to_binary(
     const char16_t *input, size_t length, char *output, base64_options options,
     last_chunk_handling_options last_chunk_handling_options) noexcept {
@@ -11945,167 +10694,37 @@ simdutf_warn_unused result base64_to_binary(
       input, length, output, options, last_chunk_handling_options);
 }
 
-template <typename chartype>
-simdutf_warn_unused result slow_base64_to_binary_safe_impl(
-    const chartype *input, size_t length, char *output, size_t &outlen,
-    base64_options options,
-    last_chunk_handling_options last_chunk_options) noexcept {
-  const bool ignore_garbage = (options & base64_default_accept_garbage) != 0;
-  auto ri = simdutf::scalar::base64::find_end(input, length, options);
-  size_t equallocation = ri.equallocation;
-  size_t equalsigns = ri.equalsigns;
-  length = ri.srclen;
-  size_t full_input_length = ri.full_input_length;
-  (void)full_input_length;
-  if (length == 0) {
-    outlen = 0;
-    if (!ignore_garbage && equalsigns > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation};
-    }
-    return {SUCCESS, 0};
-  }
-
-  // The parameters of base64_tail_decode_safe are:
-  // - dst: the output buffer
-  // - outlen: the size of the output buffer
-  // - srcr: the input buffer
-  // - length: the size of the input buffer
-  // - padded_characters: the number of padding characters
-  // - options: the options for the base64 decoder
-  // - last_chunk_options: the options for the last chunk
-  // The function will return the number of bytes written to the output buffer
-  // and the number of bytes read from the input buffer.
-  // The function will also return an error code if the input buffer is not
-  // valid base64.
-  full_result r = scalar::base64::base64_tail_decode_safe(
-      output, outlen, input, length, equalsigns, options, last_chunk_options);
-  r = scalar::base64::patch_tail_result(r, 0, 0, equallocation,
-                                        full_input_length, last_chunk_options);
-  outlen = r.output_count;
-  if (!is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
-      equalsigns > 0) {
-    // additional checks
-    if ((outlen % 3 == 0) || ((outlen % 3) + 1 + equalsigns != 4)) {
-      r.error = error_code::INVALID_BASE64_CHARACTER;
-    }
-  }
-  return {r.error, r.input_count}; // we cannot return r itself because it gets
-                                   // converted to error/output_count
-}
-simdutf_warn_unused bool base64_ignorable(char input,
-                                          base64_options options) noexcept {
-  return scalar::base64::is_ignorable(input, options);
-}
-simdutf_warn_unused bool base64_ignorable(char16_t input,
-                                          base64_options options) noexcept {
-  return scalar::base64::is_ignorable(input, options);
-}
-simdutf_warn_unused bool base64_valid(char input,
-                                      base64_options options) noexcept {
-  return scalar::base64::is_base64(input, options);
-}
-simdutf_warn_unused bool base64_valid(char16_t input,
-                                      base64_options options) noexcept {
-  return scalar::base64::is_base64(input, options);
-}
-simdutf_warn_unused bool
-base64_valid_or_padding(char input, base64_options options) noexcept {
-  return scalar::base64::is_base64_or_padding(input, options);
-}
-simdutf_warn_unused bool
-base64_valid_or_padding(char16_t input, base64_options options) noexcept {
-  return scalar::base64::is_base64_or_padding(input, options);
+simdutf_warn_unused full_result base64_to_binary_details(
+    const char *input, size_t length, char *output, base64_options options,
+    last_chunk_handling_options last_chunk_handling_options) noexcept {
+  return get_default_implementation()->base64_to_binary_details(
+      input, length, output, options, last_chunk_handling_options);
 }
 
-template <typename chartype>
-simdutf_warn_unused result base64_to_binary_safe_impl(
-    const chartype *input, size_t length, char *output, size_t &outlen,
-    base64_options options,
-    last_chunk_handling_options last_chunk_handling_options,
-    bool decode_up_to_bad_char) noexcept {
-  static_assert(std::is_same<chartype, char>::value ||
-                    std::is_same<chartype, char16_t>::value,
-                "Only char and char16_t are supported.");
-  size_t remaining_input_length = length;
-  size_t remaining_output_length = outlen;
-  size_t input_position = 0;
-  size_t output_position = 0;
-
-  // We also do a first pass using the fast path to decode as much as possible
-  size_t safe_input = (std::min)(
-      remaining_input_length,
-      base64_length_from_binary(remaining_output_length / 3 * 3, options));
-  bool done_with_partial = (safe_input == remaining_input_length);
-  simdutf::full_result r =
-      get_default_implementation()->base64_to_binary_details(
-          input + input_position, safe_input, output + output_position, options,
-          done_with_partial
-              ? last_chunk_handling_options
-              : simdutf::last_chunk_handling_options::only_full_chunks);
-  simdutf_log_assert(r.input_count <= safe_input,
-                     "You should not read more than safe_input");
-  simdutf_log_assert(r.output_count <= remaining_output_length,
-                     "You should not write more than remaining_output_length");
-  // Technically redundant, but we want to be explicit about it.
-  input_position += r.input_count;
-  output_position += r.output_count;
-  remaining_input_length -= r.input_count;
-  remaining_output_length -= r.output_count;
-  if (r.error != simdutf::error_code::SUCCESS) {
-    // There is an error. We return.
-    if (decode_up_to_bad_char &&
-        r.error == error_code::INVALID_BASE64_CHARACTER) {
-      return slow_base64_to_binary_safe_impl(
-          input, length, output, outlen, options, last_chunk_handling_options);
-    }
-    outlen = output_position;
-    return {r.error, input_position};
-  }
-
-  if (done_with_partial) {
-    // We are done. We have decoded everything.
-    outlen = output_position;
-    return {simdutf::error_code::SUCCESS, input_position};
-  }
-  // We have decoded some data, but we still have some data to decode.
-  // We need to decode the rest of the input buffer.
-  r = simdutf::scalar::base64::base64_to_binary_details_safe_impl(
-      input + input_position, remaining_input_length, output + output_position,
-      remaining_output_length, options, last_chunk_handling_options);
-  input_position += r.input_count;
-  output_position += r.output_count;
-  remaining_input_length -= r.input_count;
-  remaining_output_length -= r.output_count;
-
-  if (r.error != simdutf::error_code::SUCCESS) {
-    // There is an error. We return.
-    if (decode_up_to_bad_char &&
-        r.error == error_code::INVALID_BASE64_CHARACTER) {
-      return slow_base64_to_binary_safe_impl(
-          input, length, output, outlen, options, last_chunk_handling_options);
-    }
-    outlen = output_position;
-    return {r.error, input_position};
-  }
-  if (input_position < length) {
-    // We cannot process the entire input in one go, so we need to
-    // process it in two steps: first the fast path, then the slow path.
-    // In some cases, the processing might 'eat up' trailing ignorable
-    // characters in the fast path, but that can be a problem.
-    // suppose we have just white space followed by a single base64 character.
-    // If we first process the white space with the fast path, it will
-    // eat all of it. But, by the JavaScript standard, we should consume
-    // no character. See
-    // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
-    while (input_position > 0 &&
-           base64_ignorable(input[input_position - 1], options)) {
-      input_position--;
-    }
-  }
-  outlen = output_position;
-  return {simdutf::error_code::SUCCESS, input_position};
+simdutf_warn_unused full_result base64_to_binary_details(
+    const char16_t *input, size_t length, char *output, base64_options options,
+    last_chunk_handling_options last_chunk_handling_options) noexcept {
+  return get_default_implementation()->base64_to_binary_details(
+      input, length, output, options, last_chunk_handling_options);
 }
 
+// moved to implementation.h
+// simdutf_warn_unused bool base64_ignorable(char input,
+//                                           base64_options options) noexcept
+// simdutf_warn_unused bool base64_ignorable(char16_t input,
+//                                           base64_options options) noexcept
+// simdutf_warn_unused bool base64_valid(char input,
+//                                       base64_options options) noexcept
+// simdutf_warn_unused bool base64_valid(char16_t input,
+//                                       base64_options options) noexcept
+// simdutf_warn_unused bool
+// base64_valid_or_padding(char input, base64_options options) noexcept
+// simdutf_warn_unused bool
+// base64_valid_or_padding(char16_t input, base64_options options) noexcept
+
+// base64_to_binary_safe_impl is moved to
+// include/simdutf/base64_implementation.h
+
   #if SIMDUTF_ATOMIC_REF
 size_t atomic_binary_to_base64(const char *input, size_t length, char *output,
                                base64_options options) noexcept {
@@ -12149,23 +10768,31 @@ base64_to_binary_safe(const char16_t *input, size_t length, char *output,
       decode_up_to_bad_char);
 }
 
-simdutf_warn_unused size_t
-base64_length_from_binary(size_t length, base64_options options) noexcept {
-  return get_default_implementation()->base64_length_from_binary(length,
-                                                                 options);
-}
-
 size_t binary_to_base64(const char *input, size_t length, char *output,
                         base64_options options) noexcept {
   return get_default_implementation()->binary_to_base64(input, length, output,
                                                         options);
 }
 
+size_t binary_to_base64_with_lines(const char *input, size_t length,
+                                   char *output, size_t line_length,
+                                   base64_options options) noexcept {
+  return get_default_implementation()->binary_to_base64_with_lines(
+      input, length, output, line_length, options);
+}
+
+#if SIMDUTF_USE_STATIC_INITIALIZATION
+static const implementation *const builtin_impl_instance =
+    get_available_implementations()[SIMDUTF_STRINGIFY(
+        SIMDUTF_BUILTIN_IMPLEMENTATION)];
+#endif
 const implementation *builtin_implementation() {
-  static const implementation *builtin_impl =
+#if !SIMDUTF_USE_STATIC_INITIALIZATION
+  static const implementation *const builtin_impl_instance =
       get_available_implementations()[SIMDUTF_STRINGIFY(
           SIMDUTF_BUILTIN_IMPLEMENTATION)];
-  return builtin_impl;
+#endif
+  return builtin_impl_instance;
 }
 
 } // namespace simdutf
@@ -12179,7 +10806,6 @@ SIMDUTF_DISABLE_UNDESIRED_WARNINGS
 /* begin file src/simdutf/arm64/begin.h */
 // redefining SIMDUTF_IMPLEMENTATION to "arm64"
 // #define SIMDUTF_IMPLEMENTATION arm64
-#define SIMDUTF_SIMD_HAS_BYTEMASK 1
 /* end file src/simdutf/arm64/begin.h */
 namespace simdutf {
 namespace arm64 {
@@ -12218,8 +10844,101 @@ using namespace simd;
  * https://www.codeproject.com/Articles/276993/Base-Encoding-on-a-GPU. (2013).
  */
 
-size_t encode_base64(char *dst, const char *src, size_t srclen,
-                     base64_options options) {
+/**
+ * Insert a line feed character in the 16-byte input at index K in [0,16).
+ */
+inline uint8x16_t insert_line_feed16(uint8x16_t input, size_t K) {
+  static const uint8_t shuffle_masks[16][16] = {
+      {0x80, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 0x80, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 0x80, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 0x80, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 0x80, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 0x80, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 0x80, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 0x80, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 0x80, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 0x80, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x80, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0x80, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x80, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0x80, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0x80, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0x80}};
+  // Prepare a vector with '\n' (0x0A)
+  uint8x16_t line_feed_vector = vdupq_n_u8('\n');
+
+  // Load the precomputed shuffle mask for K
+  uint8x16_t mask = vld1q_u8(shuffle_masks[K]);
+
+  // Create a mask where 0x80 indicates the line feed position
+  uint8x16_t lf_pos = vceqq_u8(mask, vdupq_n_u8(0x80));
+
+  uint8x16_t result = vqtbl1q_u8(input, mask);
+
+  // Use vbsl to select '\n' where lf_pos is true, else keep input bytes
+  return vbslq_u8(lf_pos, line_feed_vector, result);
+}
+
+// offset is the number of characters in the current line.
+// It can range from 0 to line_length (inclusive).
+// If offset == line_length, we need to insert a line feed before writing
+// anything.
+size_t write_output_with_line_feeds(uint8_t *dst, uint8x16_t src,
+                                    size_t line_length, size_t &offset) {
+  // Fast path: no need to insert line feeds
+  // If we are at offset, we would write from [offset, offset + 16).
+  // We need that line_length >= offset + 16.
+  if (offset + 16 <= line_length) {
+    // No need to insert line feeds
+    vst1q_u8(dst, src);
+    offset += 16; // offset could be line_length here.
+    return 16;
+  }
+
+  // We have that offset + 16 >= line_length
+  // the common case is that line_length is greater than 16
+  if (simdutf_likely(line_length >= 16)) {
+    // offset <= line_length.
+    // offset + 16 > line_length
+    // So line_length - offset < 16
+    // and line_length - offset >= 0
+    uint8x16_t chunk = insert_line_feed16(src, line_length - offset);
+    vst1q_u8(dst, chunk);
+    // Not ideal to pull the last element and write it separately but
+    // it simplifies the code.
+    *(dst + 16) = vgetq_lane_u8(src, 15);
+    offset += 16 - line_length;
+    return 16 + 1; // we wrote 16 bytes plus one line feed
+  }
+  // Uncommon case where line_length < 16
+  // This is going to be SLOW.
+  else {
+    uint8_t buffer[16];
+    vst1q_u8(buffer, src);
+    size_t out_pos = 0;
+    size_t local_offset = offset;
+    for (size_t i = 0; i < 16;) {
+      if (local_offset == line_length) {
+        dst[out_pos++] = '\n';
+        local_offset = 0;
+      }
+      dst[out_pos++] = buffer[i++];
+      local_offset++;
+    }
+    offset = local_offset;
+    return out_pos;
+  }
+}
+
+template <bool insert_line_feeds>
+size_t encode_base64_impl(char *dst, const char *src, size_t srclen,
+                          base64_options options,
+                          size_t line_length = simdutf::default_line_length) {
+  size_t offset = 0;
+  if (line_length < 4) {
+    line_length = 4; // We do not support line_length less than 4
+  }
   // credit: Wojciech Muła
   uint8_t *out = (uint8_t *)dst;
   constexpr static uint8_t source_table[64] = {
@@ -12262,8 +10981,40 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     result.val[1] = vqtbl4q_u8(table, result.val[1]);
     result.val[2] = vqtbl4q_u8(table, result.val[2]);
     result.val[3] = vqtbl4q_u8(table, result.val[3]);
-    vst4q_u8(out, result);
-    out += 64;
+    if (insert_line_feeds) {
+      if (line_length >= 64) { // fast path
+        vst4q_u8(out, result);
+        if (offset + 64 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 64 - location_end;
+          std::memmove(out + location_end + 1, out + location_end, to_move);
+          out[location_end] = '\n';
+          offset = to_move;
+          out += 64 + 1;
+        } else {
+          offset += 64;
+          out += 64;
+        }
+      } else { // slow path
+        uint8x16x2_t Z0 = vzipq_u8(result.val[0], result.val[1]);
+        uint8x16x2_t Z1 = vzipq_u8(result.val[2], result.val[3]);
+        uint16x8x2_t Z2 = vzipq_u16(vreinterpretq_u16_u8(Z0.val[0]),
+                                    vreinterpretq_u16_u8(Z1.val[0]));
+        uint16x8x2_t Z3 = vzipq_u16(vreinterpretq_u16_u8(Z0.val[1]),
+                                    vreinterpretq_u16_u8(Z1.val[1]));
+        uint8x16_t T0 = vreinterpretq_u8_u16(Z2.val[0]);
+        uint8x16_t T1 = vreinterpretq_u8_u16(Z2.val[1]);
+        uint8x16_t T2 = vreinterpretq_u8_u16(Z3.val[0]);
+        uint8x16_t T3 = vreinterpretq_u8_u16(Z3.val[1]);
+        out += write_output_with_line_feeds(out, T0, line_length, offset);
+        out += write_output_with_line_feeds(out, T1, line_length, offset);
+        out += write_output_with_line_feeds(out, T2, line_length, offset);
+        out += write_output_with_line_feeds(out, T3, line_length, offset);
+      }
+    } else {
+      vst4q_u8(out, result);
+      out += 64;
+    }
   }
 
   if (i + 24 <= srclen) {
@@ -12280,17 +11031,52 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     result.val[1] = vqtbl4_u8(table, result.val[1]);
     result.val[2] = vqtbl4_u8(table, result.val[2]);
     result.val[3] = vqtbl4_u8(table, result.val[3]);
-    vst4_u8(out, result);
-    out += 32;
+    if (insert_line_feeds) {
+      if (line_length >= 32) { // fast path
+        vst4_u8(out, result);
+        if (offset + 32 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 32 - location_end;
+          std::memmove(out + location_end + 1, out + location_end, to_move);
+          out[location_end] = '\n';
+          offset = to_move;
+          out += 32 + 1;
+        } else {
+          offset += 32;
+          out += 32;
+        }
+      } else { // slow path
+        uint8x8x2_t Z0 = vzip_u8(result.val[0], result.val[1]);
+        uint8x8x2_t Z1 = vzip_u8(result.val[2], result.val[3]);
+        uint16x4x2_t Z2 = vzip_u16(vreinterpret_u16_u8(Z0.val[0]),
+                                   vreinterpret_u16_u8(Z1.val[0]));
+        uint16x4x2_t Z3 = vzip_u16(vreinterpret_u16_u8(Z0.val[1]),
+                                   vreinterpret_u16_u8(Z1.val[1]));
+        uint8x8_t T0 = vreinterpret_u8_u16(Z2.val[0]);
+        uint8x8_t T1 = vreinterpret_u8_u16(Z2.val[1]);
+        uint8x8_t T2 = vreinterpret_u8_u16(Z3.val[0]);
+        uint8x8_t T3 = vreinterpret_u8_u16(Z3.val[1]);
+        uint8x16_t TT0 = vcombine_u8(T0, T1);
+        uint8x16_t TT1 = vcombine_u8(T2, T3);
+        out += write_output_with_line_feeds(out, TT0, line_length, offset);
+        out += write_output_with_line_feeds(out, TT1, line_length, offset);
+      }
+    } else {
+      vst4_u8(out, result);
+      out += 32;
+    }
     i += 24;
   }
-
-  out += scalar::base64::tail_encode_base64((char *)out, src + i, srclen - i,
-                                            options);
-
+  out += scalar::base64::tail_encode_base64_impl<insert_line_feeds>(
+      (char *)out, src + i, srclen - i, options, line_length, offset);
   return size_t((char *)out - dst);
 }
 
+size_t encode_base64(char *dst, const char *src, size_t srclen,
+                     base64_options options) {
+  return encode_base64_impl<false>(dst, src, srclen, options);
+}
+
 static inline void compress(uint8x16_t data, uint16_t mask, char *output) {
   if (mask == 0) {
     vst1q_u8((uint8_t *)output, data);
@@ -12746,7 +11532,9 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
                          (uint32_t(uint8_t(buffer_start[2])) << 1 * 6) +
                          (uint32_t(uint8_t(buffer_start[3])) << 0 * 6))
                         << 8;
+#if !SIMDUTF_IS_BIG_ENDIAN
       triple = scalar::u32_swap_bytes(triple);
+#endif
       std::memcpy(dst, &triple, 4);
 
       dst += 3;
@@ -12758,7 +11546,9 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
                          (uint32_t(uint8_t(buffer_start[2])) << 1 * 6) +
                          (uint32_t(uint8_t(buffer_start[3])) << 0 * 6))
                         << 8;
+#if !SIMDUTF_IS_BIG_ENDIAN
       triple = scalar::u32_swap_bytes(triple);
+#endif
       std::memcpy(dst, &triple, 3);
 
       dst += 3;
@@ -13057,40 +11847,6 @@ template <size_t STEP_SIZE> struct buf_block_reader {
   size_t idx;
 };
 
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text_64(const uint8_t *text) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  in.store(reinterpret_cast<uint8_t *>(buf));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    if (buf[i] < ' ') {
-      buf[i] = '_';
-    }
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-simdutf_unused static char *format_mask(uint64_t mask) {
-  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
-  for (size_t i = 0; i < 64; i++) {
-    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
-  }
-  buf[64] = '\0';
-  return buf;
-}
-
 template <size_t STEP_SIZE>
 simdutf_really_inline
 buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
@@ -13137,6 +11893,71 @@ simdutf_really_inline void buf_block_reader<STEP_SIZE>::advance() {
 /* end file src/generic/buf_block_reader.h */
 
 // other functions
+/* begin file src/generic/base64lengths.h */
+namespace simdutf {
+namespace arm64 {
+namespace {
+namespace base64_lengths {
+
+simdutf_warn_unused size_t binary_length_from_base64(const char *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 64 <= length; pos += 64) {
+    simd8x64<uint8_t> block(reinterpret_cast<const uint8_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+simdutf_warn_unused size_t binary_length_from_base64(const char16_t *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 32 <= length; pos += 32) {
+    simd16x32<uint16_t> block(reinterpret_cast<const uint16_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char16_t c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+} // namespace base64_lengths
+} // unnamed namespace
+} // namespace arm64
+} // namespace simdutf
+/* end file src/generic/base64lengths.h */
 
 //
 // Implementation-specific overrides
@@ -13270,6 +12091,12 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
   return encode_base64(output, input, length, options);
 }
 
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  return encode_base64_impl<true>(output, input, length, options, line_length);
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return util_find(start, end, character);
@@ -13280,11 +12107,20 @@ const char16_t *implementation::find(const char16_t *start, const char16_t *end,
   return util_find(start, end, character);
 }
 
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
 } // namespace arm64
 } // namespace simdutf
 
 /* begin file src/simdutf/arm64/end.h */
-#undef SIMDUTF_SIMD_HAS_BYTEMASK
 /* end file src/simdutf/arm64/end.h */
 /* end file src/arm64/implementation.cpp */
 #endif
@@ -13332,6 +12168,13 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
   return scalar::base64::tail_encode_base64(output, input, length, options);
 }
 
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  return scalar::base64::tail_encode_base64_impl<true>(output, input, length,
+                                                       options, line_length);
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return std::find(start, end, character);
@@ -13597,9 +12440,14 @@ struct block64 {
   __m512i chunks[1];
 };
 
-template <bool base64_url>
-size_t encode_base64(char *dst, const char *src, size_t srclen,
-                     base64_options options) {
+template <bool base64_url, bool use_lines>
+size_t encode_base64_impl(char *dst, const char *src, size_t srclen,
+                          base64_options options,
+                          size_t line_length = simdutf::default_line_length) {
+  size_t offset = 0;
+  if (line_length < 4) {
+    line_length = 4; // We do not support line_length less than 4
+  }
   // credit: Wojciech Muła
   const uint8_t *input = (const uint8_t *)src;
 
@@ -13608,7 +12456,6 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
       base64_url
           ? "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
           : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
   const __m512i shuffle_input = _mm512_setr_epi32(
       0x01020001, 0x04050304, 0x07080607, 0x0a0b090a, 0x0d0e0c0d, 0x10110f10,
       0x13141213, 0x16171516, 0x191a1819, 0x1c1d1b1c, 0x1f201e1f, 0x22232122,
@@ -13618,17 +12465,58 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
   const __m512i multi_shifts = _mm512_set1_epi64(UINT64_C(0x3036242a1016040a));
   size_t size = srclen;
   __mmask64 input_mask = 0xffffffffffff; // (1 << 48) - 1
-  while (size >= 48) {
+  // We want that input == end_input means that we must stop.
+  const uint8_t *end_input = input + (size - (size % 48));
+  while (input != end_input) {
     const __m512i v = _mm512_maskz_loadu_epi8(
         input_mask, reinterpret_cast<const __m512i *>(input));
     const __m512i in = _mm512_permutexvar_epi8(shuffle_input, v);
     const __m512i indices = _mm512_multishift_epi64_epi8(multi_shifts, in);
     const __m512i result = _mm512_permutexvar_epi8(indices, lookup);
-    _mm512_storeu_si512(reinterpret_cast<__m512i *>(out), result);
-    out += 64;
+    if (use_lines) {
+      if (offset + 64 > line_length) {
+        if (line_length >= 64) {
+          __m512i expanded = _mm512_mask_expand_epi8(
+              _mm512_set1_epi8('\n'), ~(1ULL << ((line_length - offset))),
+              result);
+          _mm512_storeu_si512(reinterpret_cast<__m512i *>(out), expanded);
+          __m128i last_lane =
+              _mm512_extracti32x4_epi32(result, 3); // Lane 3 (bytes 48-63)
+          uint8_t last_byte =
+              static_cast<uint8_t>(_mm_extract_epi8(last_lane, 15));
+          out[64] = last_byte;
+          out += 65;
+          offset = 64 - (line_length - offset);
+        } else { // slow path
+          alignas(64) uint8_t local_buffer[64];
+          _mm512_storeu_si512(reinterpret_cast<__m512i *>(local_buffer),
+                              result);
+          size_t out_pos = 0;
+          size_t local_offset = offset;
+          for (size_t j = 0; j < 64;) {
+            if (local_offset == line_length) {
+              out[out_pos++] = '\n';
+              local_offset = 0;
+            }
+            out[out_pos++] = local_buffer[j++];
+            local_offset++;
+          }
+          offset = local_offset;
+          out += out_pos;
+        }
+      } else {
+        _mm512_storeu_si512(reinterpret_cast<__m512i *>(out), result);
+        offset += 64;
+        out += 64;
+      }
+    } else {
+      _mm512_storeu_si512(reinterpret_cast<__m512i *>(out), result);
+      out += 64;
+    }
     input += 48;
-    size -= 48;
   }
+  size = size % 48;
+
   input_mask = ((__mmask64)1 << size) - 1;
   const __m512i v = _mm512_maskz_loadu_epi8(
       input_mask, reinterpret_cast<const __m512i *>(input));
@@ -13643,14 +12531,65 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
   if (!padding_needed) {
     output_len = non_padded_output_len;
   }
-  __mmask64 output_mask = output_len == 64 ? (__mmask64)UINT64_MAX
-                                           : ((__mmask64)1 << output_len) - 1;
+  // If no output, we are done.
+  if (output_len == 0) {
+    return (size_t)(out - (uint8_t *)dst);
+  }
+  __mmask64 output_mask = 0xFFFFFFFFFFFFFFFF >> (64 - output_len);
   __m512i result = _mm512_mask_permutexvar_epi8(
       _mm512_set1_epi8('='), ((__mmask64)1 << non_padded_output_len) - 1,
       indices, lookup);
-  _mm512_mask_storeu_epi8(reinterpret_cast<__m512i *>(out), output_mask,
-                          result);
-  return (size_t)(out - (uint8_t *)dst) + output_len;
+  if (use_lines) {
+    if (offset + output_len > line_length) {
+      if (line_length >= 64) {
+        __m512i expanded = _mm512_mask_expand_epi8(
+            _mm512_set1_epi8('\n'), ~(1ULL << ((line_length - offset))),
+            result);
+        if (output_len == 64) {
+          _mm512_storeu_si512(reinterpret_cast<__m512i *>(out), expanded);
+          out += 64;
+          _mm512_mask_storeu_epi8(reinterpret_cast<__m512i *>(out - 63),
+                                  1ULL << 63, result);
+          out++;
+        } else {
+          output_mask = 0xFFFFFFFFFFFFFFFF >> (64 - output_len - 1);
+          _mm512_mask_storeu_epi8(reinterpret_cast<__m512i *>(out), output_mask,
+                                  expanded);
+          out += output_len + 1;
+        }
+      } else {
+        alignas(64) uint8_t local_buffer[64];
+        _mm512_storeu_si512(reinterpret_cast<__m512i *>(local_buffer), result);
+        size_t out_pos = 0;
+        size_t local_offset = offset;
+        for (size_t j = 0; j < output_len;) {
+          if (local_offset == line_length) {
+            out[out_pos++] = '\n';
+            local_offset = 0;
+          }
+          out[out_pos++] = local_buffer[j++];
+          local_offset++;
+        }
+        offset = local_offset;
+        out += out_pos;
+      }
+    } else {
+      _mm512_mask_storeu_epi8(reinterpret_cast<__m512i *>(out), output_mask,
+                              result);
+      out += output_len;
+    }
+  } else {
+    _mm512_mask_storeu_epi8(reinterpret_cast<__m512i *>(out), output_mask,
+                            result);
+    out += output_len;
+  }
+  return (size_t)(out - (uint8_t *)dst);
+}
+
+template <bool base64_url>
+size_t encode_base64(char *dst, const char *src, size_t srclen,
+                     base64_options options) {
+  return encode_base64_impl<base64_url, false>(dst, src, srclen, options);
 }
 
 template <bool base64_url, bool ignore_garbage, bool default_or_url>
@@ -13807,7 +12746,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   size_t full_input_length = ri.full_input_length;
   if (srclen == 0) {
     if (!ignore_garbage && padding_characters > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation, 0};
+      return {INVALID_BASE64_CHARACTER, equallocation, 0, true};
     }
     return {SUCCESS, full_input_length, 0};
   }
@@ -13905,8 +12844,8 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
     // We never should have that the number of base64 characters + the
     // number of padding characters is more than 4.
     if (!ignore_garbage && (idx + padding_characters > 4)) {
-      return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-              size_t(dst - dstinit), true};
+      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit),
+              true};
     }
     // The idea here is that in loose mode,
     // if there is padding at all, it must be used
@@ -13916,8 +12855,8 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
         last_chunk_options == last_chunk_handling_options::loose &&
         (idx >= 2) && padding_characters > 0 &&
         ((idx + padding_characters) & 3) != 0) {
-      return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-              size_t(dst - dstinit), true};
+      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit),
+              true};
     } else
       // The idea here is that in strict mode, we do not want to accept
       // incomplete base64 chunks. So if the chunk was otherwise valid, we
@@ -13928,7 +12867,8 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
         // The partial chunk was at src - idx
         _mm512_mask_storeu_epi8((__m512i *)dst, output_mask, shuffled);
         dst += output_len;
-        return {BASE64_INPUT_REMAINDER, equallocation, size_t(dst - dstinit)};
+        return {BASE64_INPUT_REMAINDER, equallocation, size_t(dst - dstinit),
+                true};
       } else
         // If there is a partial chunk with insufficient padding, with
         // stop_before_partial, we need to just ignore it. In "only full" mode,
@@ -14009,7 +12949,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
             _mm512_mask_storeu_epi8((__m512i *)dst, output_mask, shuffled);
             dst += output_len;
             return {INVALID_BASE64_CHARACTER, equallocation,
-                    size_t(dst - dstinit)};
+                    size_t(dst - dstinit), true};
           } else {
             _mm512_mask_storeu_epi8((__m512i *)dst, output_mask, shuffled);
             dst += output_len;
@@ -14020,7 +12960,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
       size_t output_count = size_t(dst - dstinit);
       if ((output_count % 3 == 0) ||
           ((output_count % 3) + 1 + padding_characters != 4)) {
-        return {INVALID_BASE64_CHARACTER, equallocation, output_count};
+        return {INVALID_BASE64_CHARACTER, equallocation, output_count, true};
       }
     }
     return {SUCCESS, full_input_length, size_t(dst - dstinit)};
@@ -14029,11 +12969,76 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   if (!ignore_garbage && padding_characters > 0) {
     if ((size_t(dst - dstinit) % 3 == 0) ||
         ((size_t(dst - dstinit) % 3) + 1 + padding_characters != 4)) {
-      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit)};
+      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit),
+              true};
     }
   }
   return {SUCCESS, srclen, size_t(dst - dstinit)};
 }
+
+simdutf_warn_unused size_t icelake_binary_length_from_base64(const char *input,
+                                                             size_t length) {
+  size_t count = 0;
+  const char *ptr = input;
+  const char *end = input + length;
+
+  __m512i spaces = _mm512_set1_epi8(0x20);
+  while (ptr + 64 <= end) {
+    __m512i data = _mm512_loadu_si512(reinterpret_cast<const __m512i *>(ptr));
+    uint64_t mask = _mm512_cmpgt_epi8_mask(data, spaces);
+    count += count_ones(mask);
+    ptr += 64;
+  }
+
+  while (ptr < end) {
+    count += (*ptr > 0x20) ? 1 : 0;
+    ptr++;
+  }
+
+  size_t padding = 0;
+  size_t pos = length;
+  while (pos > 0 && padding < 2) {
+    char c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+simdutf_warn_unused size_t
+icelake_binary_length_from_base64(const char16_t *input, size_t length) {
+  size_t count = 0;
+  const char16_t *ptr = input;
+  const char16_t *end = input + length;
+
+  __m512i spaces = _mm512_set1_epi16(0x20);
+  while (ptr + 32 <= end) {
+    __m512i data = _mm512_loadu_si512(reinterpret_cast<const __m512i *>(ptr));
+    __mmask32 mask = _mm512_cmpgt_epi16_mask(data, spaces);
+    count += _mm_popcnt_u32(mask);
+    ptr += 32;
+  }
+
+  while (ptr < end) {
+    count += (*ptr > 0x20) ? 1 : 0;
+    ptr++;
+  }
+
+  size_t padding = 0;
+  size_t pos = length;
+  while (pos > 0 && padding < 2) {
+    char16_t c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
 /* end file src/icelake/icelake_base64.inl.cpp */
 /* begin file src/icelake/icelake_find.inl.cpp */
 simdutf_really_inline const char *util_find(const char *start, const char *end,
@@ -14055,6 +13060,8 @@ simdutf_really_inline const char *util_find(const char *start, const char *end,
     __m512i data = _mm512_maskz_loadu_epi8(
         load_mask, reinterpret_cast<const __m512i *>(start));
     __mmask64 match_mask = _mm512_cmpeq_epi8_mask(data, char_vec);
+    match_mask &= load_mask; // When searching for null terminators, this
+                             // prevents false positives
 
     if (match_mask != 0) {
       size_t index = _tzcnt_u64(match_mask);
@@ -14144,6 +13151,8 @@ simdutf_really_inline const char16_t *util_find(const char16_t *start,
     __m512i data = _mm512_maskz_loadu_epi16(
         load_mask, reinterpret_cast<const __m512i *>(start));
     __mmask32 match_mask = _mm512_cmpeq_epi16_mask(data, char_vec);
+    match_mask &= load_mask; // When searching for null terminators, this
+                             // prevents false positives
 
     if (match_mask != 0) {
       size_t index = _tzcnt_u32(match_mask);
@@ -14323,6 +13332,18 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
   }
 }
 
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  if (options & base64_url) {
+    return encode_base64_impl<true, true>(output, input, length, options,
+                                          line_length);
+  } else {
+    return encode_base64_impl<false, true>(output, input, length, options,
+                                           line_length);
+  }
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return util_find(start, end, character);
@@ -14332,6 +13353,16 @@ const char16_t *implementation::find(const char16_t *start, const char16_t *end,
   return util_find(start, end, character);
 }
 
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return icelake_binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return icelake_binary_length_from_base64(input, length);
+}
+
 } // namespace icelake
 } // namespace simdutf
 
@@ -14410,6 +13441,7 @@ using namespace simd;
 
 template <bool base64_url>
 simdutf_really_inline __m256i lookup_pshufb_improved(const __m256i input) {
+  // Precomputed shuffle masks for K = 1 to 16
   // credit: Wojciech Muła
   __m256i result = _mm256_subs_epu8(input, _mm256_set1_epi8(51));
   const __m256i less = _mm256_cmpgt_epi8(_mm256_set1_epi8(26), input);
@@ -14436,9 +13468,110 @@ simdutf_really_inline __m256i lookup_pshufb_improved(const __m256i input) {
   return _mm256_add_epi8(result, input);
 }
 
-template <bool isbase64url>
-size_t encode_base64(char *dst, const char *src, size_t srclen,
-                     base64_options options) {
+simdutf_really_inline __m256i insert_line_feed32(__m256i input, int K) {
+
+  static const uint8_t low_table[16][32] = {
+      {0x80, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0,    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 0x80, 1, 2, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1,    2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 0x80, 2, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2,    3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 0x80, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3,    4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 0x80, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4,    5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 0x80, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5,    6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 0x80, 6, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6,    7, 8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 0x80, 7, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7,    8, 9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 0x80, 8, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8,    9, 10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 0x80, 9,  10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9,    10, 11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x80, 10, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,   11, 12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0x80, 11, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,   12, 13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x80, 12, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,   13, 14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0x80, 13, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,   14, 15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0x80, 14,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,   15},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0x80,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
+  static const uint8_t high_table[16][32] = {
+      {0,    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0x80, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1,    2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 0x80, 1, 2, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2,    3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 0x80, 2, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3,    4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 0x80, 3, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4,    5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 0x80, 4, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5,    6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 0x80, 5, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6,    7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 0x80, 6, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7,    8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 0x80, 7, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8,    9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 0x80, 8, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,    10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 0x80, 9,  10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,   11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x80, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,   12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0x80, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,   13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x80, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,   14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0x80, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,   15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0x80, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0x80}};
+
+  __m256i line_feed_vector = _mm256_set1_epi8('\n');
+  if (K >= 16) {
+    __m256i mask = _mm256_loadu_si256((const __m256i *)high_table[K - 16]);
+    __m256i lf_pos =
+        _mm256_cmpeq_epi8(mask, _mm256_set1_epi8(static_cast<char>(0x80)));
+    __m256i shuffled = _mm256_shuffle_epi8(input, mask);
+    __m256i result = _mm256_blendv_epi8(shuffled, line_feed_vector, lf_pos);
+    return result;
+  }
+  // Shift input right by 1 byte
+  __m256i shift = _mm256_alignr_epi8(
+      input, _mm256_permute2x128_si256(input, input, 0x21), 15);
+
+  input = _mm256_blend_epi32(input, shift, 0xF0);
+
+  __m256i mask = _mm256_loadu_si256((const __m256i *)low_table[K]);
+
+  __m256i lf_pos =
+      _mm256_cmpeq_epi8(mask, _mm256_set1_epi8(static_cast<char>(0x80)));
+  __m256i shuffled = _mm256_shuffle_epi8(input, mask);
+
+  __m256i result = _mm256_blendv_epi8(shuffled, line_feed_vector, lf_pos);
+  return result;
+}
+
+template <bool isbase64url, bool use_lines>
+size_t
+avx2_encode_base64_impl(char *dst, const char *src, size_t srclen,
+                        base64_options options,
+                        size_t line_length = simdutf::default_line_length) {
+  size_t offset = 0;
+
+  if (line_length < 4) {
+    line_length = 4; // We do not support line_length less than 4
+  }
   // credit: Wojciech Muła
   const uint8_t *input = (const uint8_t *)src;
 
@@ -14504,20 +13637,123 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     const __m256i input2 = _mm256_or_si256(t1_2, t3_2);
     const __m256i input3 = _mm256_or_si256(t1_3, t3_3);
 
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
-                        lookup_pshufb_improved<isbase64url>(input0));
-    out += 32;
+    if (use_lines) {
+      if (line_length >= 32) { // fast path
+        __m256i result;
+        result = lookup_pshufb_improved<isbase64url>(input0);
+        if (offset + 32 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 32 - location_end;
+          // We could do this, or extract instead.
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 1), result);
+          _mm256_storeu_si256(
+              reinterpret_cast<__m256i *>(out),
+              insert_line_feed32(result, static_cast<int>(location_end)));
+          offset = to_move;
+          out += 32 + 1;
+        } else {
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out), result);
+          offset += 32;
+          out += 32;
+        }
+        result = lookup_pshufb_improved<isbase64url>(input1);
+
+        if (offset + 32 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 32 - location_end;
+
+          // We could do this, or extract instead.
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 1), result);
+          _mm256_storeu_si256(
+              reinterpret_cast<__m256i *>(out),
+              insert_line_feed32(result, static_cast<int>(location_end)));
+          // see above.
+          // out[32] = static_cast<uint8_t>(_mm256_extract_epi8(result, 31));
+          offset = to_move;
+          out += 32 + 1;
+        } else {
 
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
-                        lookup_pshufb_improved<isbase64url>(input1));
-    out += 32;
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out), result);
 
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
-                        lookup_pshufb_improved<isbase64url>(input2));
-    out += 32;
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
-                        lookup_pshufb_improved<isbase64url>(input3));
-    out += 32;
+          offset += 32;
+          out += 32;
+        }
+        result = lookup_pshufb_improved<isbase64url>(input2);
+
+        if (offset + 32 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 32 - location_end;
+
+          // We could do this, or extract instead.
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 1), result);
+          _mm256_storeu_si256(
+              reinterpret_cast<__m256i *>(out),
+              insert_line_feed32(result, static_cast<int>(location_end)));
+          // see above.
+          // out[32] = static_cast<uint8_t>(_mm256_extract_epi8(result, 31));
+          offset = to_move;
+          out += 32 + 1;
+        } else {
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out), result);
+          offset += 32;
+          out += 32;
+        }
+        result = lookup_pshufb_improved<isbase64url>(input3);
+
+        if (offset + 32 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 32 - location_end;
+
+          // We could do this, or extract instead.
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 1), result);
+          _mm256_storeu_si256(
+              reinterpret_cast<__m256i *>(out),
+              insert_line_feed32(result, static_cast<int>(location_end)));
+          // see above.
+          // out[32] = static_cast<uint8_t>(_mm256_extract_epi8(result, 31));
+          offset = to_move;
+          out += 32 + 1;
+        } else {
+          _mm256_storeu_si256(reinterpret_cast<__m256i *>(out), result);
+          offset += 32;
+          out += 32;
+        }
+      } else { // slow path
+        // could be optimized
+        uint8_t buffer[128];
+        _mm256_storeu_si256(reinterpret_cast<__m256i *>(buffer),
+                            lookup_pshufb_improved<isbase64url>(input0));
+        _mm256_storeu_si256(reinterpret_cast<__m256i *>(buffer + 32),
+                            lookup_pshufb_improved<isbase64url>(input1));
+        _mm256_storeu_si256(reinterpret_cast<__m256i *>(buffer + 64),
+                            lookup_pshufb_improved<isbase64url>(input2));
+        _mm256_storeu_si256(reinterpret_cast<__m256i *>(buffer + 96),
+                            lookup_pshufb_improved<isbase64url>(input3));
+        size_t out_pos = 0;
+        size_t local_offset = offset;
+        for (size_t j = 0; j < 128;) {
+          if (local_offset == line_length) {
+            out[out_pos++] = '\n';
+            local_offset = 0;
+          }
+          out[out_pos++] = buffer[j++];
+          local_offset++;
+        }
+        offset = local_offset;
+        out += out_pos;
+      }
+    } else {
+      _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
+                          lookup_pshufb_improved<isbase64url>(input0));
+      _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 32),
+                          lookup_pshufb_improved<isbase64url>(input1));
+      _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 64),
+                          lookup_pshufb_improved<isbase64url>(input2));
+      _mm256_storeu_si256(reinterpret_cast<__m256i *>(out + 96),
+                          lookup_pshufb_improved<isbase64url>(input3));
+
+      out += 128;
+    }
   }
   for (; i + 28 <= srclen; i += 24) {
     // lo = [xxxx|DDDC|CCBB|BAAA]
@@ -14539,12 +13775,57 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     const __m256i t3 = _mm256_mullo_epi16(t2, _mm256_set1_epi32(0x01000010));
     const __m256i indices = _mm256_or_si256(t1, t3);
 
-    _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
-                        lookup_pshufb_improved<isbase64url>(indices));
-    out += 32;
+    if (use_lines) {
+      if (line_length >= 32) { // fast path
+        _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
+                            lookup_pshufb_improved<isbase64url>(indices));
+
+        if (offset + 32 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 32 - location_end;
+          std::memmove(out + location_end + 1, out + location_end, to_move);
+          out[location_end] = '\n';
+          offset = to_move;
+          out += 32 + 1;
+        } else {
+          offset += 32;
+          out += 32;
+        }
+      } else { // slow path
+        // could be optimized
+        alignas(32) uint8_t buffer[32];
+        _mm256_storeu_si256(reinterpret_cast<__m256i *>(buffer),
+                            lookup_pshufb_improved<isbase64url>(indices));
+        std::memcpy(out, buffer, 32);
+        size_t out_pos = 0;
+        size_t local_offset = offset;
+        for (size_t j = 0; j < 32;) {
+          if (local_offset == line_length) {
+            out[out_pos++] = '\n';
+            local_offset = 0;
+          }
+          out[out_pos++] = buffer[j++];
+          local_offset++;
+        }
+        offset = local_offset;
+        out += out_pos;
+      }
+    } else {
+      _mm256_storeu_si256(reinterpret_cast<__m256i *>(out),
+                          lookup_pshufb_improved<isbase64url>(indices));
+
+      out += 32;
+    }
   }
-  return i / 3 * 4 + scalar::base64::tail_encode_base64((char *)out, src + i,
-                                                        srclen - i, options);
+  return ((char *)out - (char *)dst) +
+         scalar::base64::tail_encode_base64_impl<use_lines>(
+             (char *)out, src + i, srclen - i, options, line_length, offset);
+}
+
+template <bool isbase64url>
+size_t encode_base64(char *dst, const char *src, size_t srclen,
+                     base64_options options) {
+  return avx2_encode_base64_impl<isbase64url, false>(dst, src, srclen, options);
 }
 
 static inline void compress(__m128i data, uint16_t mask, char *output) {
@@ -14622,7 +13903,7 @@ simdutf_really_inline void base64_decode_block_safe(char *out,
                                                     const char *src) {
   base64_decode(out,
                 _mm256_loadu_si256(reinterpret_cast<const __m256i *>(src)));
-  char buffer[32]; // We enforce safety with a buffer.
+  alignas(32) char buffer[32]; // We enforce safety with a buffer.
   base64_decode(
       buffer, _mm256_loadu_si256(reinterpret_cast<const __m256i *>(src + 32)));
   std::memcpy(out + 24, buffer, 24);
@@ -14674,7 +13955,7 @@ class block64 {
 
   simdutf_really_inline void base64_decode_block_safe(char *out) {
     base64_decode(out, chunks[0]);
-    char buffer[32]; // We enforce safety with a buffer.
+    alignas(32) char buffer[32]; // We enforce safety with a buffer.
     base64_decode(buffer, chunks[1]);
     std::memcpy(out + 24, buffer, 24);
   }
@@ -14900,6 +14181,73 @@ class block64 {
     return 63;
   }
 };
+
+simdutf_warn_unused size_t avx2_binary_length_from_base64(const char *input,
+                                                          size_t length) {
+  size_t count = 0;
+  const char *ptr = input;
+  const char *end = input + length;
+
+  __m256i spaces = _mm256_set1_epi8(0x20);
+  while (ptr + 32 <= end) {
+    __m256i data = _mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptr));
+    __m256i gt_space = _mm256_cmpgt_epi8(data, spaces);
+    uint32_t mask = static_cast<uint32_t>(_mm256_movemask_epi8(gt_space));
+    count += count_ones(mask);
+    ptr += 32;
+  }
+
+  while (ptr < end) {
+    count += (*ptr > 0x20) ? 1 : 0;
+    ptr++;
+  }
+
+  size_t padding = 0;
+  size_t pos = length;
+  while (pos > 0 && padding < 2) {
+    char c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+simdutf_warn_unused size_t avx2_binary_length_from_base64(const char16_t *input,
+                                                          size_t length) {
+  size_t count = 0;
+  const char16_t *ptr = input;
+  const char16_t *end = input + length;
+
+  __m256i spaces = _mm256_set1_epi16(0x20);
+  while (ptr + 16 <= end) {
+    __m256i data = _mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptr));
+    __m256i gt_space = _mm256_cmpgt_epi16(data, spaces);
+    uint32_t mask = static_cast<uint32_t>(_mm256_movemask_epi8(gt_space));
+    count += count_ones(mask);
+    ptr += 16;
+  }
+  count /= 2;
+
+  while (ptr < end) {
+    count += (*ptr > 0x20) ? 1 : 0;
+    ptr++;
+  }
+
+  size_t padding = 0;
+  size_t pos = length;
+  while (pos > 0 && padding < 2) {
+    char16_t c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
 /* end file src/haswell/avx2_base64.cpp */
 
 } // unnamed namespace
@@ -14939,40 +14287,6 @@ template <size_t STEP_SIZE> struct buf_block_reader {
   size_t idx;
 };
 
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text_64(const uint8_t *text) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  in.store(reinterpret_cast<uint8_t *>(buf));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    if (buf[i] < ' ') {
-      buf[i] = '_';
-    }
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-simdutf_unused static char *format_mask(uint64_t mask) {
-  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
-  for (size_t i = 0; i < 64; i++) {
-    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
-  }
-  buf[64] = '\0';
-  return buf;
-}
-
 template <size_t STEP_SIZE>
 simdutf_really_inline
 buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
@@ -15077,7 +14391,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   size_t full_input_length = ri.full_input_length;
   if (srclen == 0) {
     if (!ignore_garbage && equalsigns > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation, 0};
+      return {INVALID_BASE64_CHARACTER, equallocation, 0, true};
     }
     return {SUCCESS, full_input_length, 0};
   }
@@ -15244,7 +14558,8 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   if (!ignore_garbage && equalsigns > 0) {
     if ((size_t(dst - dstinit) % 3 == 0) ||
         ((size_t(dst - dstinit) % 3) + 1 + equalsigns != 4)) {
-      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit)};
+      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit),
+              true};
     }
   }
   return {SUCCESS, srclen, size_t(dst - dstinit)};
@@ -15460,9 +14775,21 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
                                         char *output,
                                         base64_options options) const noexcept {
   if (options & base64_url) {
-    return encode_base64<true>(output, input, length, options);
+    return encode_base64<true>(output, input, length, options);
+  } else {
+    return encode_base64<false>(output, input, length, options);
+  }
+}
+
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  if (options & base64_url) {
+    return avx2_encode_base64_impl<true, true>(output, input, length, options,
+                                               line_length);
   } else {
-    return encode_base64<false>(output, input, length, options);
+    return avx2_encode_base64_impl<false, true>(output, input, length, options,
+                                                line_length);
   }
 }
 
@@ -15476,6 +14803,16 @@ const char16_t *implementation::find(const char16_t *start, const char16_t *end,
   return util::find(start, end, character);
 }
 
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return avx2_binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return avx2_binary_length_from_base64(input, length);
+}
+
 } // namespace haswell
 } // namespace simdutf
 
@@ -16551,6 +15888,307 @@ enum class ErrorReporting {
   none,       // no error checking is done, we assume valid inputs
 };
 
+#if (SIMDUTF_FEATURE_UTF16 || SIMDUTF_FEATURE_UTF32) && SIMDUTF_FEATURE_UTF8
+/* begin file src/ppc64/ppc64_convert_utf16_to_utf8.cpp */
+/*
+    The vectorized algorithm works on single SSE register i.e., it
+    loads eight 16-bit code units.
+
+    We consider three cases:
+    1. an input register contains no surrogates and each value
+       is in range 0x0000 .. 0x07ff.
+    2. an input register contains no surrogates and values are
+       is in range 0x0000 .. 0xffff.
+    3. an input register contains surrogates --- i.e. codepoints
+       can have 16 or 32 bits.
+
+    Ad 1.
+
+    When values are less than 0x0800, it means that a 16-bit code unit
+    can be converted into: 1) single UTF8 byte (when it is an ASCII
+    char) or 2) two UTF8 bytes.
+
+    For this case we do only some shuffle to obtain these 2-byte
+    codes and finally compress the whole SSE register with a single
+    shuffle.
+
+    We need 256-entry lookup table to get a compression pattern
+    and the number of output bytes in the compressed vector register.
+    Each entry occupies 17 bytes.
+
+    Ad 2.
+
+    When values fit in 16-bit code units, but are above 0x07ff, then
+    a single word may produce one, two or three UTF8 bytes.
+
+    We prepare data for all these three cases in two registers.
+    The first register contains lower two UTF8 bytes (used in all
+    cases), while the second one contains just the third byte for
+    the three-UTF8-bytes case.
+
+    Finally these two registers are interleaved forming eight-element
+    array of 32-bit values. The array spans two SSE registers.
+    The bytes from the registers are compressed using two shuffles.
+
+    We need 256-entry lookup table to get a compression pattern
+    and the number of output bytes in the compressed vector register.
+    Each entry occupies 17 bytes.
+
+    To summarize:
+    - We need two 256-entry tables that have 8704 bytes in total.
+*/
+
+// Auxiliary procedure used by UTF-16 and UTF-32 into UTF-8.
+// Note the pointer is passed by reference, it is updated by the procedure.
+template <typename T>
+simdutf_really_inline void ppc64_convert_utf16_to_1_2_3_bytes_of_utf8(
+    const vector_u16 in, uint16_t one_byte_bitmask,
+    const T one_or_two_bytes_bytemask, uint16_t one_or_two_bytes_bitmask,
+    char *&utf8_output) {
+  // case: code units from register produce either 1, 2 or 3 UTF-8 bytes
+#if SIMDUTF_IS_BIG_ENDIAN
+  const auto dup_lsb =
+      vector_u8(1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15);
+#else
+  const auto dup_lsb =
+      vector_u8(0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+
+  /* In this branch we handle three cases:
+     1. [0000|0000|0ccc|cccc] => [0ccc|cccc]                           -
+    single UFT-8 byte
+     2. [0000|0bbb|bbcc|cccc] => [110b|bbbb], [10cc|cccc]              - two
+    UTF-8 bytes
+     3. [aaaa|bbbb|bbcc|cccc] => [1110|aaaa], [10bb|bbbb], [10cc|cccc] -
+    three UTF-8 bytes
+
+    We expand the input word (16-bit) into two code units (32-bit), thus
+    we have room for four bytes. However, we need five distinct bit
+    layouts. Note that the last byte in cases #2 and #3 is the same.
+
+    We precompute byte 1 for case #1 and the common byte for cases #2 & #3
+    in register t2.
+
+    We precompute byte 1 for case #3 and -- **conditionally** -- precompute
+    either byte 1 for case #2 or byte 2 for case #3. Note that they
+    differ by exactly one bit.
+
+    Finally from these two code units we build proper UTF-8 sequence, taking
+    into account the case (i.e, the number of bytes to write).
+  */
+  /**
+   * Given [aaaa|bbbb|bbcc|cccc] our goal is to produce:
+   * t2 => [0ccc|cccc] [10cc|cccc]
+   * s4 => [1110|aaaa] ([110b|bbbb] OR [10bb|bbbb])
+   */
+  // [aaaa|bbbb|bbcc|cccc] => [bbcc|cccc|bbcc|cccc]
+  const auto t0 = as_vector_u16(dup_lsb.lookup_16(as_vector_u8(in)));
+
+  // [bbcc|cccc|bbcc|cccc] => [00cc|cccc|0bcc|cccc]
+  const auto t1 = t0 & uint16_t(0b0011111101111111);
+  // [00cc|cccc|0bcc|cccc] => [10cc|cccc|0bcc|cccc]
+  const auto t2 = t1 | uint16_t(0b1000000000000000);
+
+  // in = [aaaa|bbbb|bbcc|cccc]
+  // a0 = [0000|0000|0000|aaaa]
+  const auto a0 = in.shr<12>();
+  // b0 = [aabb|bbbb|cccc|cc00]
+  const auto b0 = in.shl<2>();
+  // s0 = [00bb|bbbb|00cc|cccc]
+  const auto s0 = select(uint16_t(0x3f00), b0, a0);
+
+  // s3 = [11bb|bbbb|1110|aaaa]
+  const auto s3 = s0 | uint16_t(0b1100000011100000);
+
+  const auto m0 =
+      ~as_vector_u16(one_or_two_bytes_bytemask) & uint16_t(0b0100000000000000);
+  const auto s4 = s3 ^ m0;
+
+  // 4. compress 32-bit code units into 1, 2 or 3 bytes -- 2 x shuffle
+  const uint16_t mask =
+      (one_byte_bitmask & 0x5555) | (one_or_two_bytes_bitmask & 0xaaaa);
+  if (mask == 0) {
+    // We only have three-byte code units. Use fast path.
+#if SIMDUTF_IS_BIG_ENDIAN
+    // Lookups produced by scripts/ppc64_convert_utf16_to_utf8.py
+    const auto shuffle0 =
+        vector_u8(1, 0, 16, 3, 2, 18, 5, 4, 20, 7, 6, 22, 9, 8, 24, 11);
+    const auto shuffle1 = vector_u8(10, 26, 13, 12, 28, 15, 14, 30, -1, -1, -1,
+                                    -1, -1, -1, -1, -1);
+#else
+    const auto shuffle0 =
+        vector_u8(0, 1, 17, 2, 3, 19, 4, 5, 21, 6, 7, 23, 8, 9, 25, 10);
+    const auto shuffle1 = vector_u8(11, 27, 12, 13, 29, 14, 15, 31, -1, -1, -1,
+                                    -1, -1, -1, -1, -1);
+#endif // SIMDUTF_IS_BIG_ENDIAN
+    const auto utf8_0 = shuffle0.lookup_32(as_vector_u8(s4), as_vector_u8(t2));
+    const auto utf8_1 = shuffle1.lookup_32(as_vector_u8(s4), as_vector_u8(t2));
+
+    utf8_0.store(utf8_output);
+    utf8_output += 16;
+    utf8_1.store(utf8_output);
+    utf8_output += 8;
+    return;
+  }
+
+  const uint8_t mask0 = uint8_t(mask);
+
+  const uint8_t *row0 =
+      &simdutf::tables::ppc64_utf16_to_utf8::pack_1_2_3_utf8_bytes[mask0][0];
+  const auto shuffle0 = vector_u8::load(row0 + 1);
+
+  const auto utf8_0 = shuffle0.lookup_32(as_vector_u8(s4), as_vector_u8(t2));
+  const uint8_t mask1 = static_cast<uint8_t>(mask >> 8);
+
+  const uint8_t *row1 =
+      &simdutf::tables::ppc64_utf16_to_utf8::pack_1_2_3_utf8_bytes[mask1][0];
+  const auto shuffle1 = vector_u8::load(row1 + 1) + uint8_t(8);
+  const auto utf8_1 = shuffle1.lookup_32(as_vector_u8(s4), as_vector_u8(t2));
+
+  utf8_0.store(utf8_output);
+  utf8_output += row0[0];
+  utf8_1.store(utf8_output);
+  utf8_output += row1[0];
+}
+
+struct utf16_to_utf8_t {
+  error_code err;
+  const char16_t *input;
+  char *output;
+};
+
+/*
+  Returns utf16_to_utf8_t value
+  A scalar routine should carry on the conversion of the tail,
+  iff there was no error.
+*/
+template <endianness big_endian>
+utf16_to_utf8_t ppc64_convert_utf16_to_utf8(const char16_t *buf, size_t len,
+                                            char *utf8_output) {
+
+  const char16_t *end = buf + len;
+
+  const auto v_f800 = vector_u16(0xf800);
+  const auto v_d800 = vector_u16(0xd800);
+  const size_t safety_margin =
+      12; // to avoid overruns, see issue
+          // https://github.com/simdutf/simdutf/issues/92
+
+  while (end - buf >= std::ptrdiff_t(16 + safety_margin)) {
+    auto in = vector_u16::load(buf);
+    if (not match_system(big_endian)) {
+      in = in.swap_bytes();
+    }
+    // a single 16-bit UTF-16 word can yield 1, 2 or 3 UTF-8 bytes
+    if (in.is_ascii()) {
+      auto nextin = vector_u16::load(buf + vector_u16::ELEMENTS);
+      if (not match_system(big_endian)) {
+        nextin = nextin.swap_bytes();
+      }
+
+      if (nextin.is_ascii()) {
+        // 1. pack the bytes
+        const auto utf8_packed = vector_u16::pack(in, nextin);
+        // 2. store (16 bytes)
+        utf8_packed.store(utf8_output);
+        // 3. adjust pointers
+        buf += 16;
+        utf8_output += 16;
+        continue; // we are done for this round!
+      }
+
+      // next block is not ASCII
+      const auto utf8_packed = vector_u16::pack(in, in);
+      // 2. store (16 bytes)
+      utf8_packed.store(utf8_output);
+      // 3. adjust pointers
+      buf += 8;
+      utf8_output += 8;
+      in = nextin;
+      // fallback
+    }
+
+    // no bits set above 7th bit
+    const auto one_byte_bytemask = in < uint16_t(1 << 7);
+    const uint16_t one_byte_bitmask = one_byte_bytemask.to_bitmask();
+
+    // no bits set above 11th bit
+    const auto one_or_two_bytes_bytemask = in < uint16_t(1 << 11);
+    const uint16_t one_or_two_bytes_bitmask =
+        one_or_two_bytes_bytemask.to_bitmask();
+
+    if (one_or_two_bytes_bitmask == 0xffff) {
+      write_v_u16_11bits_to_utf8(
+          in, utf8_output, as_vector_u8(one_byte_bytemask), one_byte_bitmask);
+      buf += 8;
+      continue;
+    }
+
+    // 1. Check if there are any surrogate word in the input chunk.
+    //    We have also to deal with situation when there is a surrogate word
+    //    at the end of a chunk.
+    const auto surrogates_bytemask = (in & v_f800) == v_d800;
+
+    // bitmask = 0x0000 if there are no surrogates
+    //         = 0xc000 if the last word is a surrogate
+    const uint16_t surrogates_bitmask = surrogates_bytemask.to_bitmask();
+    // It might seem like checking for surrogates_bitmask == 0xc000 could help.
+    // However, it is likely an uncommon occurrence.
+    if (surrogates_bitmask == 0x0000) {
+      ppc64_convert_utf16_to_1_2_3_bytes_of_utf8(
+          in, one_byte_bitmask, one_or_two_bytes_bytemask,
+          one_or_two_bytes_bitmask, utf8_output);
+
+      buf += 8;
+      // surrogate pair(s) in a register
+    } else {
+      // Let us do a scalar fallback.
+      // It may seem wasteful to use scalar code, but being efficient with SIMD
+      // in the presence of surrogate pairs may require non-trivial tables.
+      size_t forward = 15;
+      size_t k = 0;
+      if (size_t(end - buf) < forward + 1) {
+        forward = size_t(end - buf - 1);
+      }
+      for (; k < forward; k++) {
+        uint16_t word = scalar::utf16::swap_if_needed<big_endian>(buf[k]);
+        if ((word & 0xFF80) == 0) {
+          *utf8_output++ = uint8_t(word);
+        } else if ((word & 0xF800) == 0) {
+          *utf8_output++ = uint8_t((word >> 6) | 0b11000000);
+          *utf8_output++ = uint8_t((word & 0b111111) | 0b10000000);
+        } else if ((word & 0xF800) != 0xD800) {
+          *utf8_output++ = uint8_t((word >> 12) | 0b11100000);
+          *utf8_output++ = uint8_t(((word >> 6) & 0b111111) | 0b10000000);
+          *utf8_output++ = uint8_t((word & 0b111111) | 0b10000000);
+        } else {
+          // must be a surrogate pair
+          uint16_t diff = uint16_t(word - 0xD800);
+          uint16_t next_word =
+              scalar::utf16::swap_if_needed<big_endian>(buf[k + 1]);
+          k++;
+          uint16_t diff2 = uint16_t(next_word - 0xDC00);
+          if ((diff | diff2) > 0x3FF) {
+            return utf16_to_utf8_t{error_code::SURROGATE, buf + k - 1,
+                                   utf8_output};
+          }
+          uint32_t value = (diff << 10) + diff2 + 0x10000;
+          *utf8_output++ = uint8_t((value >> 18) | 0b11110000);
+          *utf8_output++ = uint8_t(((value >> 12) & 0b111111) | 0b10000000);
+          *utf8_output++ = uint8_t(((value >> 6) & 0b111111) | 0b10000000);
+          *utf8_output++ = uint8_t((value & 0b111111) | 0b10000000);
+        }
+      }
+      buf += k;
+    }
+  } // while
+
+  return utf16_to_utf8_t{error_code::SUCCESS, buf, utf8_output};
+}
+/* end file src/ppc64/ppc64_convert_utf16_to_utf8.cpp */
+#endif // (SIMDUTF_FEATURE_UTF16 || SIMDUTF_FEATURE_UTF32) &&
+       // SIMDUTF_FEATURE_UTF8
+
 /* begin file src/ppc64/ppc64_base64.cpp */
 /*
  * References and further reading:
@@ -16580,9 +16218,9 @@ enum class ErrorReporting {
  * https://www.codeproject.com/Articles/276993/Base-Encoding-on-a-GPU. (2013).
  *
  * AMD XOP specific: http://0x80.pl/notesen/2016-01-12-sse-base64-encoding.html
- * Altivec has capabilites of AMD XOP (or vice versa): shuffle using 2 vectors
+ * Altivec has capabilities of AMD XOP (or vice versa): shuffle using 2 vectors
  * and variable shifts, thus this implementation shares some code solution
- * (modulo intrisic function names).
+ * (modulo intrinsic function names).
  */
 
 constexpr bool with_base64_std = false;
@@ -17095,7 +16733,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   size_t full_input_length = ri.full_input_length;
   if (srclen == 0) {
     if (!ignore_garbage && equalsigns > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation, 0};
+      return {INVALID_BASE64_CHARACTER, equallocation, 0, true};
     }
     return {SUCCESS, full_input_length, 0};
   }
@@ -17262,7 +16900,8 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   if (!ignore_garbage && equalsigns > 0) {
     if ((size_t(dst - dstinit) % 3 == 0) ||
         ((size_t(dst - dstinit) % 3) + 1 + equalsigns != 4)) {
-      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit)};
+      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit),
+              true};
     }
   }
   return {SUCCESS, srclen, size_t(dst - dstinit)};
@@ -17590,6 +17229,14 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
     return encode_base64<false>(output, input, length, options);
   }
 }
+
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  return scalar::base64::tail_encode_base64_impl<true>(output, input, length,
+                                                       options, line_length);
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return util::find(start, end, character);
@@ -17695,8 +17342,8 @@ rvv_utf32_store_utf16_m4(uint16_t *dst, vuint32m4_t utf32, size_t vl,
 /* end file src/rvv/rvv_utf8_to.inl.cpp */
 
 /* begin file src/rvv/rvv_find.cpp */
-simdutf_really_inline const char *util_find(const char *start, const char *end,
-                                            char character) noexcept {
+const char *implementation::find(const char *start, const char *end,
+                                 char character) const noexcept {
   const char *src = start;
   for (size_t len = end - start, vl; len > 0; len -= vl, src += vl) {
     vl = __riscv_vsetvl_e8m8(len);
@@ -17709,9 +17356,8 @@ simdutf_really_inline const char *util_find(const char *start, const char *end,
   return end;
 }
 
-simdutf_really_inline const char16_t *util_find(const char16_t *start,
-                                                const char16_t *end,
-                                                char16_t character) noexcept {
+const char16_t *implementation::find(const char16_t *start, const char16_t *end,
+                                     char16_t character) const noexcept {
   const char16_t *src = start;
   for (size_t len = end - start, vl; len > 0; len -= vl, src += vl) {
     vl = __riscv_vsetvl_e16m8(len);
@@ -17759,14 +17405,11 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
   return scalar::base64::tail_encode_base64(output, input, length, options);
 }
 
-const char *implementation::find(const char *start, const char *end,
-                                 char character) const noexcept {
-  return util_find(start, end, character);
-}
-
-const char16_t *implementation::find(const char16_t *start, const char16_t *end,
-                                     char16_t character) const noexcept {
-  return util_find(start, end, character);
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  return scalar::base64::tail_encode_base64_impl<true>(output, input, length,
+                                                       options, line_length);
 }
 
 } // namespace rvv
@@ -17834,7 +17477,6 @@ using namespace simd;
  */
 
 // --- encoding ----------------------------------------------------
-
 template <bool base64_url> __m128i lookup_pshufb_improved(const __m128i input) {
   // credit: Wojciech Muła
   // reduce  0..51 -> 0
@@ -17866,9 +17508,47 @@ template <bool base64_url> __m128i lookup_pshufb_improved(const __m128i input) {
   return _mm_add_epi8(result, input);
 }
 
-template <bool isbase64url>
-size_t encode_base64(char *dst, const char *src, size_t srclen,
-                     base64_options options) {
+inline __m128i insert_line_feed16(__m128i input, size_t K) {
+  static const uint8_t shuffle_masks[16][16] = {
+      {0x80, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 0x80, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 0x80, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 0x80, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 0x80, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 0x80, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 0x80, 6, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 0x80, 7, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 0x80, 8, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 0x80, 9, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x80, 10, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0x80, 11, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0x80, 12, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0x80, 13, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0x80, 14},
+      {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0x80}};
+  // Prepare a vector with '\n' (0x0A)
+  __m128i line_feed_vector = _mm_set1_epi8('\n');
+
+  // Load the precomputed shuffle mask for K (index K-1)
+  __m128i mask = _mm_loadu_si128((__m128i *)shuffle_masks[K]);
+  __m128i lf_pos = _mm_cmpeq_epi8(mask, _mm_set1_epi8(static_cast<char>(0x80)));
+
+  // Perform the shuffle to reposition the K bytes
+  __m128i shuffled = _mm_shuffle_epi8(input, mask);
+
+  // Blend with line_feed_vector to insert '\n' at the appropriate positions
+  __m128i result = _mm_blendv_epi8(shuffled, line_feed_vector, lf_pos);
+
+  return result;
+}
+template <bool isbase64url, bool use_lines>
+size_t encode_base64_impl(char *dst, const char *src, size_t srclen,
+                          base64_options options,
+                          size_t line_length = simdutf::default_line_length) {
+  size_t offset = 0;
+  if (line_length < 4) {
+    line_length = 4; // We do not support line_length less than 4
+  }
   // credit: Wojciech Muła
   // SSE (lookup: pshufb improved unrolled)
   const uint8_t *input = (const uint8_t *)src;
@@ -17918,21 +17598,98 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     const __m128i input2 = _mm_or_si128(t1_2, t3_2);
     const __m128i input3 = _mm_or_si128(t1_3, t3_3);
 
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
-                     lookup_pshufb_improved<isbase64url>(input0));
-    out += 16;
-
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
-                     lookup_pshufb_improved<isbase64url>(input1));
-    out += 16;
-
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
-                     lookup_pshufb_improved<isbase64url>(input2));
-    out += 16;
+    const __m128i t0 = lookup_pshufb_improved<isbase64url>(input0);
+    const __m128i t1 = lookup_pshufb_improved<isbase64url>(input1);
+    const __m128i t2 = lookup_pshufb_improved<isbase64url>(input2);
+    const __m128i t3 = lookup_pshufb_improved<isbase64url>(input3);
+
+    if (use_lines) {
+      if (line_length >= 64) { // fast path
+        if (offset + 64 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 64 - location_end;
+          if (location_end < 16) {
+            // We can store or extract store. See below.
+            //_mm_storeu_si128(reinterpret_cast<__m128i *>(out+1), t0);
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
+                             insert_line_feed16(t0, location_end));
+            out[16] = static_cast<uint8_t>(_mm_extract_epi8(t0, 15));
+            out += 17;
+          } else {
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out), t0);
+            out += 16;
+          }
+          if (location_end >= 16 && location_end < 32) {
+            // We can store or extract store. See below.
+            //_mm_storeu_si128(reinterpret_cast<__m128i *>(out+1), t1);
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
+                             insert_line_feed16(t1, location_end - 16));
+            out[16] = static_cast<uint8_t>(_mm_extract_epi8(t1, 15));
+            out += 17;
+          } else {
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out), t1);
+            out += 16;
+          }
+          if (location_end >= 32 && location_end < 48) {
+            // We can store or extract store. See below.
+            //_mm_storeu_si128(reinterpret_cast<__m128i *>(out+1), t2);
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
+                             insert_line_feed16(t2, location_end - 32));
+            out[16] = static_cast<uint8_t>(_mm_extract_epi8(t2, 15));
+            out += 17;
+          } else {
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out), t2);
+            out += 16;
+          }
+          if (location_end >= 48) {
+            // We can store or extract store. See below.
+            //_mm_storeu_si128(reinterpret_cast<__m128i *>(out+1), t3);
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
+                             insert_line_feed16(t3, location_end - 48));
+            out[16] = static_cast<uint8_t>(_mm_extract_epi8(t3, 15));
+            out += 17;
+          } else {
+            _mm_storeu_si128(reinterpret_cast<__m128i *>(out), t3);
+            out += 16;
+          }
+          offset = to_move;
+        } else {
 
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
-                     lookup_pshufb_improved<isbase64url>(input3));
-    out += 16;
+          _mm_storeu_si128(reinterpret_cast<__m128i *>(out), t0);
+          _mm_storeu_si128(reinterpret_cast<__m128i *>(out + 16), t1);
+          _mm_storeu_si128(reinterpret_cast<__m128i *>(out + 32), t2);
+          _mm_storeu_si128(reinterpret_cast<__m128i *>(out + 48), t3);
+          offset += 64;
+          out += 64;
+        }
+      } else { // slow path
+        // could be optimized
+        alignas(64) uint8_t buffer[64];
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(buffer), t0);
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(buffer + 16), t1);
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(buffer + 32), t2);
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(buffer + 48), t3);
+        std::memcpy(out, buffer, 64);
+        size_t out_pos = 0;
+        size_t local_offset = offset;
+        for (size_t j = 0; j < 64;) {
+          if (local_offset == line_length) {
+            out[out_pos++] = '\n';
+            local_offset = 0;
+          }
+          out[out_pos++] = buffer[j++];
+          local_offset++;
+        }
+        offset = local_offset;
+        out += out_pos;
+      }
+    } else {
+      _mm_storeu_si128(reinterpret_cast<__m128i *>(out), t0);
+      _mm_storeu_si128(reinterpret_cast<__m128i *>(out + 16), t1);
+      _mm_storeu_si128(reinterpret_cast<__m128i *>(out + 32), t2);
+      _mm_storeu_si128(reinterpret_cast<__m128i *>(out + 48), t3);
+      out += 64;
+    }
   }
   for (; i + 16 <= srclen; i += 12) {
 
@@ -17970,13 +17727,55 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     // res   = [00dddddd|00cccccc|00bbbbbb|00aaaaaa] = t1 | t3
     const __m128i indices = _mm_or_si128(t1, t3);
 
-    _mm_storeu_si128(reinterpret_cast<__m128i *>(out),
-                     lookup_pshufb_improved<isbase64url>(indices));
-    out += 16;
+    const __m128i T0 = lookup_pshufb_improved<isbase64url>(indices);
+
+    _mm_storeu_si128(reinterpret_cast<__m128i *>(out), T0);
+
+    if (use_lines) {
+      if (line_length >= 16) { // fast path
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(out), T0);
+        if (offset + 16 > line_length) {
+          size_t location_end = line_length - offset;
+          size_t to_move = 16 - location_end;
+          std::memmove(out + location_end + 1, out + location_end, to_move);
+          out[location_end] = '\n';
+          offset = to_move;
+          out += 16 + 1;
+        } else {
+          offset += 16;
+          out += 16;
+        }
+      } else { // slow path
+        // could be optimized
+        uint8_t buffer[16];
+        _mm_storeu_si128(reinterpret_cast<__m128i *>(buffer), T0);
+        size_t out_pos = 0;
+        size_t local_offset = offset;
+        for (size_t j = 0; j < 16;) {
+          if (local_offset == line_length) {
+            out[out_pos++] = '\n';
+            local_offset = 0;
+          }
+          out[out_pos++] = buffer[j++];
+          local_offset++;
+        }
+        offset = local_offset;
+        out += out_pos;
+      }
+    } else {
+      _mm_storeu_si128(reinterpret_cast<__m128i *>(out), T0);
+      out += 16;
+    }
   }
+  return ((char *)out - (char *)dst) +
+         scalar::base64::tail_encode_base64_impl<use_lines>(
+             (char *)out, src + i, srclen - i, options, line_length, offset);
+}
 
-  return i / 3 * 4 + scalar::base64::tail_encode_base64((char *)out, src + i,
-                                                        srclen - i, options);
+template <bool isbase64url>
+size_t encode_base64(char *dst, const char *src, size_t srclen,
+                     base64_options options) {
+  return encode_base64_impl<isbase64url, false>(dst, src, srclen, options);
 }
 
 // --- decoding -----------------------------------------------
@@ -18360,40 +18159,6 @@ template <size_t STEP_SIZE> struct buf_block_reader {
   size_t idx;
 };
 
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text_64(const uint8_t *text) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  in.store(reinterpret_cast<uint8_t *>(buf));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    if (buf[i] < ' ') {
-      buf[i] = '_';
-    }
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-simdutf_unused static char *format_mask(uint64_t mask) {
-  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
-  for (size_t i = 0; i < 64; i++) {
-    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
-  }
-  buf[64] = '\0';
-  return buf;
-}
-
 template <size_t STEP_SIZE>
 simdutf_really_inline
 buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
@@ -18496,7 +18261,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   size_t full_input_length = ri.full_input_length;
   if (srclen == 0) {
     if (!ignore_garbage && equalsigns > 0) {
-      return {INVALID_BASE64_CHARACTER, equallocation, 0};
+      return {INVALID_BASE64_CHARACTER, equallocation, 0, true};
     }
     return {SUCCESS, full_input_length, 0};
   }
@@ -18663,7 +18428,8 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   if (!ignore_garbage && equalsigns > 0) {
     if ((size_t(dst - dstinit) % 3 == 0) ||
         ((size_t(dst - dstinit) % 3) + 1 + equalsigns != 4)) {
-      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit)};
+      return {INVALID_BASE64_CHARACTER, equallocation, size_t(dst - dstinit),
+              true};
     }
   }
   return {SUCCESS, srclen, size_t(dst - dstinit)};
@@ -18751,6 +18517,71 @@ find(const char16_t *start, const char16_t *end, char16_t character) noexcept {
 } // namespace westmere
 } // namespace simdutf
 /* end file src/generic/find.h */
+/* begin file src/generic/base64lengths.h */
+namespace simdutf {
+namespace westmere {
+namespace {
+namespace base64_lengths {
+
+simdutf_warn_unused size_t binary_length_from_base64(const char *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 64 <= length; pos += 64) {
+    simd8x64<uint8_t> block(reinterpret_cast<const uint8_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+simdutf_warn_unused size_t binary_length_from_base64(const char16_t *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 32 <= length; pos += 32) {
+    simd16x32<uint16_t> block(reinterpret_cast<const uint16_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char16_t c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+} // namespace base64_lengths
+} // unnamed namespace
+} // namespace westmere
+} // namespace simdutf
+/* end file src/generic/base64lengths.h */
 
 //
 // Implementation-specific overrides
@@ -18889,6 +18720,19 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
   }
 }
 
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  if (options & base64_url) {
+    return encode_base64_impl<true, true>(output, input, length, options,
+                                          line_length);
+
+  } else {
+    return encode_base64_impl<false, true>(output, input, length, options,
+                                           line_length);
+  }
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return util::find(start, end, character);
@@ -18899,6 +18743,16 @@ const char16_t *implementation::find(const char16_t *start, const char16_t *end,
   return util::find(start, end, character);
 }
 
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
 } // namespace westmere
 } // namespace simdutf
 
@@ -18913,22 +18767,28 @@ SIMDUTF_UNTARGET_REGION
 /* end file src/simdutf/westmere/end.h */
 /* end file src/westmere/implementation.cpp */
 #endif
-#if SIMDUTF_IMPLEMENTATION_LSX
-/* begin file src/lsx/implementation.cpp */
-/* begin file src/simdutf/lsx/begin.h */
-// redefining SIMDUTF_IMPLEMENTATION to "lsx"
-// #define SIMDUTF_IMPLEMENTATION lsx
+#if SIMDUTF_IMPLEMENTATION_LASX
+/* begin file src/lasx/implementation.cpp */
+/* begin file src/simdutf/lasx/begin.h */
+// redefining SIMDUTF_IMPLEMENTATION to "lasx"
+// #define SIMDUTF_IMPLEMENTATION lasx
 #define SIMDUTF_SIMD_HAS_UNSIGNED_CMP 1
-/* end file src/simdutf/lsx/begin.h */
+
+#if SIMDUTF_CAN_ALWAYS_RUN_LASX
+// nothing needed.
+#else
+SIMDUTF_TARGET_LASX
+#endif
+/* end file src/simdutf/lasx/begin.h */
 namespace simdutf {
-namespace lsx {
+namespace lasx {
 namespace {
-#ifndef SIMDUTF_LSX_H
-  #error "lsx.h must be included"
+#ifndef SIMDUTF_LASX_H
+  #error "lasx.h must be included"
 #endif
 using namespace simd;
 
-/* begin file src/lsx/lsx_base64.cpp */
+/* begin file src/lasx/lasx_base64.cpp */
 /**
  * References and further reading:
  *
@@ -18969,100 +18829,118 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
           : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   uint8_t *out = (uint8_t *)dst;
 
-  v16u8 shuf;
-  __m128i v_fc0fc00, v_3f03f0, shift_r, shift_l, base64_tbl0, base64_tbl1,
+  v32u8 shuf;
+  __m256i v_fc0fc00, v_3f03f0, shift_r, shift_l, base64_tbl0, base64_tbl1,
       base64_tbl2, base64_tbl3;
-  if (srclen >= 16) {
-    shuf = v16u8{1, 0, 2, 1, 4, 3, 5, 4, 7, 6, 8, 7, 10, 9, 11, 10};
-    v_fc0fc00 = __lsx_vreplgr2vr_w(uint32_t(0x0fc0fc00));
-    v_3f03f0 = __lsx_vreplgr2vr_w(uint32_t(0x003f03f0));
-    shift_r = __lsx_vreplgr2vr_w(uint32_t(0x0006000a));
-    shift_l = __lsx_vreplgr2vr_w(uint32_t(0x00080004));
-    base64_tbl0 = __lsx_vld(lookup_tbl, 0);
-    base64_tbl1 = __lsx_vld(lookup_tbl, 16);
-    base64_tbl2 = __lsx_vld(lookup_tbl, 32);
-    base64_tbl3 = __lsx_vld(lookup_tbl, 48);
-  }
+  if (srclen >= 28) {
+    shuf = v32u8{1, 0, 2, 1, 4, 3, 5, 4, 7, 6, 8, 7, 10, 9, 11, 10,
+                 1, 0, 2, 1, 4, 3, 5, 4, 7, 6, 8, 7, 10, 9, 11, 10};
 
+    v_fc0fc00 = __lasx_xvreplgr2vr_w(uint32_t(0x0fc0fc00));
+    v_3f03f0 = __lasx_xvreplgr2vr_w(uint32_t(0x003f03f0));
+    shift_r = __lasx_xvreplgr2vr_w(uint32_t(0x0006000a));
+    shift_l = __lasx_xvreplgr2vr_w(uint32_t(0x00080004));
+    base64_tbl0 = ____m256i(__lsx_vld(lookup_tbl, 0));
+    base64_tbl1 = ____m256i(__lsx_vld(lookup_tbl, 16));
+    base64_tbl2 = ____m256i(__lsx_vld(lookup_tbl, 32));
+    base64_tbl3 = ____m256i(__lsx_vld(lookup_tbl, 48));
+  }
   size_t i = 0;
-  for (; i + 52 <= srclen; i += 48) {
-    __m128i in0 =
+  for (; i + 100 <= srclen; i += 96) {
+    __m128i in0_lo =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 0);
-    __m128i in1 =
+    __m128i in0_hi =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 1);
-    __m128i in2 =
+    __m128i in1_lo =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 2);
-    __m128i in3 =
+    __m128i in1_hi =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 3);
+    __m128i in2_lo =
+        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 4);
+    __m128i in2_hi =
+        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 5);
+    __m128i in3_lo =
+        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 6);
+    __m128i in3_hi =
+        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 7);
 
-    in0 = __lsx_vshuf_b(in0, in0, (__m128i)shuf);
-    in1 = __lsx_vshuf_b(in1, in1, (__m128i)shuf);
-    in2 = __lsx_vshuf_b(in2, in2, (__m128i)shuf);
-    in3 = __lsx_vshuf_b(in3, in3, (__m128i)shuf);
+    __m256i in0 = lasx_set_q(in0_hi, in0_lo);
+    __m256i in1 = lasx_set_q(in1_hi, in1_lo);
+    __m256i in2 = lasx_set_q(in2_hi, in2_lo);
+    __m256i in3 = lasx_set_q(in3_hi, in3_lo);
+
+    in0 = __lasx_xvshuf_b(in0, in0, (__m256i)shuf);
+    in1 = __lasx_xvshuf_b(in1, in1, (__m256i)shuf);
+    in2 = __lasx_xvshuf_b(in2, in2, (__m256i)shuf);
+    in3 = __lasx_xvshuf_b(in3, in3, (__m256i)shuf);
 
-    __m128i t0_0 = __lsx_vand_v(in0, v_fc0fc00);
-    __m128i t0_1 = __lsx_vand_v(in1, v_fc0fc00);
-    __m128i t0_2 = __lsx_vand_v(in2, v_fc0fc00);
-    __m128i t0_3 = __lsx_vand_v(in3, v_fc0fc00);
+    __m256i t0_0 = __lasx_xvand_v(in0, v_fc0fc00);
+    __m256i t0_1 = __lasx_xvand_v(in1, v_fc0fc00);
+    __m256i t0_2 = __lasx_xvand_v(in2, v_fc0fc00);
+    __m256i t0_3 = __lasx_xvand_v(in3, v_fc0fc00);
 
-    __m128i t1_0 = __lsx_vsrl_h(t0_0, shift_r);
-    __m128i t1_1 = __lsx_vsrl_h(t0_1, shift_r);
-    __m128i t1_2 = __lsx_vsrl_h(t0_2, shift_r);
-    __m128i t1_3 = __lsx_vsrl_h(t0_3, shift_r);
+    __m256i t1_0 = __lasx_xvsrl_h(t0_0, shift_r);
+    __m256i t1_1 = __lasx_xvsrl_h(t0_1, shift_r);
+    __m256i t1_2 = __lasx_xvsrl_h(t0_2, shift_r);
+    __m256i t1_3 = __lasx_xvsrl_h(t0_3, shift_r);
 
-    __m128i t2_0 = __lsx_vand_v(in0, v_3f03f0);
-    __m128i t2_1 = __lsx_vand_v(in1, v_3f03f0);
-    __m128i t2_2 = __lsx_vand_v(in2, v_3f03f0);
-    __m128i t2_3 = __lsx_vand_v(in3, v_3f03f0);
+    __m256i t2_0 = __lasx_xvand_v(in0, v_3f03f0);
+    __m256i t2_1 = __lasx_xvand_v(in1, v_3f03f0);
+    __m256i t2_2 = __lasx_xvand_v(in2, v_3f03f0);
+    __m256i t2_3 = __lasx_xvand_v(in3, v_3f03f0);
 
-    __m128i t3_0 = __lsx_vsll_h(t2_0, shift_l);
-    __m128i t3_1 = __lsx_vsll_h(t2_1, shift_l);
-    __m128i t3_2 = __lsx_vsll_h(t2_2, shift_l);
-    __m128i t3_3 = __lsx_vsll_h(t2_3, shift_l);
+    __m256i t3_0 = __lasx_xvsll_h(t2_0, shift_l);
+    __m256i t3_1 = __lasx_xvsll_h(t2_1, shift_l);
+    __m256i t3_2 = __lasx_xvsll_h(t2_2, shift_l);
+    __m256i t3_3 = __lasx_xvsll_h(t2_3, shift_l);
 
-    __m128i input0 = __lsx_vor_v(t1_0, t3_0);
-    __m128i input0_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input0);
-    __m128i input0_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
-                                         __lsx_vsub_b(input0, __lsx_vldi(32)));
-    __m128i input0_mask = __lsx_vslei_bu(input0, 31);
-    __m128i input0_result =
-        __lsx_vbitsel_v(input0_shuf1, input0_shuf0, input0_mask);
-    __lsx_vst(input0_result, reinterpret_cast<__m128i *>(out), 0);
-    out += 16;
+    __m256i input0 = __lasx_xvor_v(t1_0, t3_0);
+    __m256i input0_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input0);
+    __m256i input0_shuf1 = __lasx_xvshuf_b(
+        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input0, __lasx_xvldi(32)));
+    __m256i input0_mask = __lasx_xvslei_bu(input0, 31);
+    __m256i input0_result =
+        __lasx_xvbitsel_v(input0_shuf1, input0_shuf0, input0_mask);
+    __lasx_xvst(input0_result, reinterpret_cast<__m256i *>(out), 0);
+    out += 32;
 
-    __m128i input1 = __lsx_vor_v(t1_1, t3_1);
-    __m128i input1_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input1);
-    __m128i input1_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
-                                         __lsx_vsub_b(input1, __lsx_vldi(32)));
-    __m128i input1_mask = __lsx_vslei_bu(input1, 31);
-    __m128i input1_result =
-        __lsx_vbitsel_v(input1_shuf1, input1_shuf0, input1_mask);
-    __lsx_vst(input1_result, reinterpret_cast<__m128i *>(out), 0);
-    out += 16;
+    __m256i input1 = __lasx_xvor_v(t1_1, t3_1);
+    __m256i input1_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input1);
+    __m256i input1_shuf1 = __lasx_xvshuf_b(
+        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input1, __lasx_xvldi(32)));
+    __m256i input1_mask = __lasx_xvslei_bu(input1, 31);
+    __m256i input1_result =
+        __lasx_xvbitsel_v(input1_shuf1, input1_shuf0, input1_mask);
+    __lasx_xvst(input1_result, reinterpret_cast<__m256i *>(out), 0);
+    out += 32;
 
-    __m128i input2 = __lsx_vor_v(t1_2, t3_2);
-    __m128i input2_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input2);
-    __m128i input2_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
-                                         __lsx_vsub_b(input2, __lsx_vldi(32)));
-    __m128i input2_mask = __lsx_vslei_bu(input2, 31);
-    __m128i input2_result =
-        __lsx_vbitsel_v(input2_shuf1, input2_shuf0, input2_mask);
-    __lsx_vst(input2_result, reinterpret_cast<__m128i *>(out), 0);
-    out += 16;
+    __m256i input2 = __lasx_xvor_v(t1_2, t3_2);
+    __m256i input2_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input2);
+    __m256i input2_shuf1 = __lasx_xvshuf_b(
+        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input2, __lasx_xvldi(32)));
+    __m256i input2_mask = __lasx_xvslei_bu(input2, 31);
+    __m256i input2_result =
+        __lasx_xvbitsel_v(input2_shuf1, input2_shuf0, input2_mask);
+    __lasx_xvst(input2_result, reinterpret_cast<__m256i *>(out), 0);
+    out += 32;
 
-    __m128i input3 = __lsx_vor_v(t1_3, t3_3);
-    __m128i input3_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input3);
-    __m128i input3_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
-                                         __lsx_vsub_b(input3, __lsx_vldi(32)));
-    __m128i input3_mask = __lsx_vslei_bu(input3, 31);
-    __m128i input3_result =
-        __lsx_vbitsel_v(input3_shuf1, input3_shuf0, input3_mask);
-    __lsx_vst(input3_result, reinterpret_cast<__m128i *>(out), 0);
-    out += 16;
+    __m256i input3 = __lasx_xvor_v(t1_3, t3_3);
+    __m256i input3_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input3);
+    __m256i input3_shuf1 = __lasx_xvshuf_b(
+        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input3, __lasx_xvldi(32)));
+    __m256i input3_mask = __lasx_xvslei_bu(input3, 31);
+    __m256i input3_result =
+        __lasx_xvbitsel_v(input3_shuf1, input3_shuf0, input3_mask);
+    __lasx_xvst(input3_result, reinterpret_cast<__m256i *>(out), 0);
+    out += 32;
   }
-  for (; i + 16 <= srclen; i += 12) {
+  for (; i + 28 <= srclen; i += 24) {
 
-    __m128i in = __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 0);
+    __m128i in_lo = __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 0);
+    __m128i in_hi =
+        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 1);
+
+    __m256i in = lasx_set_q(in_hi, in_lo);
 
     // bytes from groups A, B and C are needed in separate 32-bit lanes
     // in = [DDDD|CCCC|BBBB|AAAA]
@@ -19076,33 +18954,32 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     //      [bbbbcccc|ccdddddd|aaaaaabb|bbbbcccc]
     //           ^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^
     //                  processed bits
-    in = __lsx_vshuf_b(in, in, (__m128i)shuf);
+    in = __lasx_xvshuf_b(in, in, (__m256i)shuf);
 
     // unpacking
     // t0    = [0000cccc|cc000000|aaaaaa00|00000000]
-    __m128i t0 = __lsx_vand_v(in, v_fc0fc00);
+    __m256i t0 = __lasx_xvand_v(in, v_fc0fc00);
     // t1    = [00000000|00cccccc|00000000|00aaaaaa]
     //          ((c >> 6),  (a >> 10))
-    __m128i t1 = __lsx_vsrl_h(t0, shift_r);
+    __m256i t1 = __lasx_xvsrl_h(t0, shift_r);
 
     // t2    = [00000000|00dddddd|000000bb|bbbb0000]
-    __m128i t2 = __lsx_vand_v(in, v_3f03f0);
+    __m256i t2 = __lasx_xvand_v(in, v_3f03f0);
     // t3    = [00dddddd|00000000|00bbbbbb|00000000]
     //          ((d << 8), (b << 4))
-    __m128i t3 = __lsx_vsll_h(t2, shift_l);
+    __m256i t3 = __lasx_xvsll_h(t2, shift_l);
 
     // res   = [00dddddd|00cccccc|00bbbbbb|00aaaaaa] = t1 | t3
-    __m128i indices = __lsx_vor_v(t1, t3);
-
-    __m128i indices_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, indices);
-    __m128i indices_shuf1 = __lsx_vshuf_b(
-        base64_tbl3, base64_tbl2, __lsx_vsub_b(indices, __lsx_vldi(32)));
-    __m128i indices_mask = __lsx_vslei_bu(indices, 31);
-    __m128i indices_result =
-        __lsx_vbitsel_v(indices_shuf1, indices_shuf0, indices_mask);
+    __m256i indices = __lasx_xvor_v(t1, t3);
 
-    __lsx_vst(indices_result, reinterpret_cast<__m128i *>(out), 0);
-    out += 16;
+    __m256i indices_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, indices);
+    __m256i indices_shuf1 = __lasx_xvshuf_b(
+        base64_tbl3, base64_tbl2, __lasx_xvsub_b(indices, __lasx_xvldi(32)));
+    __m256i indices_mask = __lasx_xvslei_bu(indices, 31);
+    __m256i indices_result =
+        __lasx_xvbitsel_v(indices_shuf1, indices_shuf0, indices_mask);
+    __lasx_xvst(indices_result, reinterpret_cast<__m256i *>(out), 0);
+    out += 32;
   }
 
   return i / 3 * 4 + scalar::base64::tail_encode_base64((char *)out, src + i,
@@ -19126,7 +19003,7 @@ static inline void compress(__m128i data, uint16_t mask, char *output) {
                     tables::base64::thintable_epi8[mask2]};
 
   // we increment by 0x08 the second half of the mask
-  v4u32 hi = {0, 0, 0x08080808, 0x08080808};
+  const v4u32 hi = {0, 0, 0x08080808, 0x08080808};
   __m128i shufmask1 = __lsx_vadd_b((__m128i)shufmask, (__m128i)hi);
 
   // this is the version "nearly pruned"
@@ -19148,115 +19025,111 @@ static inline void compress(__m128i data, uint16_t mask, char *output) {
 }
 
 struct block64 {
-  __m128i chunks[4];
+  __m256i chunks[2];
 };
 
 template <bool base64_url, bool default_or_url>
-static inline uint16_t to_base64_mask(__m128i *src, bool *error) {
-  const v16u8 ascii_space_tbl = {0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-                                 0x0,  0x9, 0xa, 0x0, 0xc, 0xd, 0x0, 0x0};
+static inline uint32_t to_base64_mask(__m256i *src, bool *error) {
+  __m256i ascii_space_tbl =
+      ____m256i((__m128i)v16u8{0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                               0x9, 0xa, 0x0, 0xc, 0xd, 0x0, 0x0});
   // credit: aqrit
-  /*
-  '0'(0x30)-'9'(0x39) => delta_values_index = 4
-  'A'(0x41)-'Z'(0x5a) => delta_values_index = 4/5/12(4+8)
-  'a'(0x61)-'z'(0x7a) => delta_values_index = 6/7/14(6+8)
-  '+'(0x2b)           => delta_values_index = 3
-  '/'(0x2f)           => delta_values_index = 2+8 = 10
-  '-'(0x2d)           => delta_values_index = 2+8 = 10
-  '_'(0x5f)           => delta_values_index = 5+8 = 13
-  */
-  v16u8 delta_asso;
+  __m256i delta_asso;
   if (default_or_url) {
-    delta_asso = v16u8{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-                       0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x16};
+    delta_asso =
+        ____m256i((__m128i)v16u8{0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0,
+                                 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0x16});
   } else {
-    delta_asso = v16u8{0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-                       0x0, 0x0, 0x0, 0x0, 0x0, 0xF, 0x0, 0xF};
+    delta_asso =
+        ____m256i((__m128i)v16u8{0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0,
+                                 0x0, 0x0, 0x0, 0x0, 0xF, 0x0, 0xF});
   }
-  v16i8 delta_values;
+  __m256i delta_values;
   if (default_or_url) {
-    delta_values =
-        v16i8{int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0x13),
-              int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
-              int8_t(0xB9), int8_t(0x00), int8_t(0xFF), int8_t(0x11),
-              int8_t(0xFF), int8_t(0xBF), int8_t(0x10), int8_t(0xB9)};
+    delta_values = ____m256i(
+        (__m128i)v16i8{int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0x13),
+                       int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
+                       int8_t(0xB9), int8_t(0x00), int8_t(0xFF), int8_t(0x11),
+                       int8_t(0xFF), int8_t(0xBF), int8_t(0x10), int8_t(0xB9)});
   } else if (base64_url) {
-    delta_values =
-        v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
-              int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
-              int8_t(0xB9), int8_t(0x00), int8_t(0x11), int8_t(0xC3),
-              int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0xB9)};
+    delta_values = ____m256i(
+        (__m128i)v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
+                       int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
+                       int8_t(0xB9), int8_t(0x00), int8_t(0x11), int8_t(0xC3),
+                       int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0xB9)});
   } else {
-    delta_values =
-        v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
-              int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
-              int8_t(0xB9), int8_t(0x00), int8_t(0x10), int8_t(0xC3),
-              int8_t(0xBF), int8_t(0xBF), int8_t(0xB9), int8_t(0xB9)};
+    delta_values = ____m256i(
+        (__m128i)v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
+                       int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
+                       int8_t(0xB9), int8_t(0x00), int8_t(0x10), int8_t(0xC3),
+                       int8_t(0xBF), int8_t(0xBF), int8_t(0xB9), int8_t(0xB9)});
   }
 
-  v16u8 check_asso;
+  __m256i check_asso;
   if (default_or_url) {
-    check_asso = v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-                       0x01, 0x01, 0x03, 0x07, 0x0B, 0x0E, 0x0B, 0x06};
+    check_asso = ____m256i((__m128i)v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01,
+                                          0x01, 0x01, 0x01, 0x01, 0x03, 0x07,
+                                          0x0B, 0x0E, 0x0B, 0x06});
+
   } else if (base64_url) {
-    check_asso = v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-                       0x01, 0x01, 0x03, 0x07, 0x0B, 0x06, 0x0B, 0x12};
+    check_asso = ____m256i((__m128i)v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01,
+                                          0x01, 0x01, 0x01, 0x01, 0x03, 0x07,
+                                          0x0B, 0x06, 0x0B, 0x12});
   } else {
-    check_asso = v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-                       0x01, 0x01, 0x03, 0x07, 0x0B, 0x0B, 0x0B, 0x0F};
+    check_asso = ____m256i((__m128i)v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01,
+                                          0x01, 0x01, 0x01, 0x01, 0x03, 0x07,
+                                          0x0B, 0x0B, 0x0B, 0x0F});
   }
 
-  v16i8 check_values;
+  __m256i check_values;
   if (default_or_url) {
-    check_values =
-        v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
-              int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
-              int8_t(0xB5), int8_t(0xA1), int8_t(0x00), int8_t(0x80),
-              int8_t(0x00), int8_t(0x80), int8_t(0x00), int8_t(0x80)};
+
+    check_values = ____m256i(
+        (__m128i)v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
+                       int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
+                       int8_t(0xB5), int8_t(0xA1), int8_t(0x00), int8_t(0x80),
+                       int8_t(0x00), int8_t(0x80), int8_t(0x00), int8_t(0x80)});
   } else if (base64_url) {
-    check_values = v16i8{int8_t(0x0),  int8_t(0x80), int8_t(0x80), int8_t(0x80),
-                         int8_t(0xCF), int8_t(0xBF), int8_t(0xD3), int8_t(0xA6),
-                         int8_t(0xB5), int8_t(0x86), int8_t(0xD0), int8_t(0x80),
-                         int8_t(0xB0), int8_t(0x80), int8_t(0x0),  int8_t(0x0)};
+    check_values = ____m256i(
+        (__m128i)v16i8{int8_t(0x0), int8_t(0x80), int8_t(0x80), int8_t(0x80),
+                       int8_t(0xCF), int8_t(0xBF), int8_t(0xD3), int8_t(0xA6),
+                       int8_t(0xB5), int8_t(0x86), int8_t(0xD0), int8_t(0x80),
+                       int8_t(0xB0), int8_t(0x80), int8_t(0x0), int8_t(0x0)});
   } else {
-    check_values =
-        v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
-              int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
-              int8_t(0xB5), int8_t(0x86), int8_t(0xD1), int8_t(0x80),
-              int8_t(0xB1), int8_t(0x80), int8_t(0x91), int8_t(0x80)};
+    check_values = ____m256i(
+        (__m128i)v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
+                       int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
+                       int8_t(0xB5), int8_t(0x86), int8_t(0xD1), int8_t(0x80),
+                       int8_t(0xB1), int8_t(0x80), int8_t(0x91), int8_t(0x80)});
   }
 
-  const __m128i shifted = __lsx_vsrli_b(*src, 3);
-  __m128i asso_index = __lsx_vand_v(*src, __lsx_vldi(0xF));
-  const __m128i delta_hash =
-      __lsx_vavgr_bu(__lsx_vshuf_b((__m128i)delta_asso, (__m128i)delta_asso,
-                                   (__m128i)asso_index),
-                     shifted);
-  const __m128i check_hash =
-      __lsx_vavgr_bu(__lsx_vshuf_b((__m128i)check_asso, (__m128i)check_asso,
-                                   (__m128i)asso_index),
-                     shifted);
+  __m256i shifted = __lasx_xvsrli_b(*src, 3);
+  __m256i asso_index = __lasx_xvand_v(*src, __lasx_xvldi(0xF));
+  __m256i delta_hash = __lasx_xvavgr_bu(
+      __lasx_xvshuf_b(delta_asso, delta_asso, asso_index), shifted);
+  __m256i check_hash = __lasx_xvavgr_bu(
+      __lasx_xvshuf_b(check_asso, check_asso, asso_index), shifted);
 
-  const __m128i out =
-      __lsx_vsadd_b(__lsx_vshuf_b((__m128i)delta_values, (__m128i)delta_values,
-                                  (__m128i)delta_hash),
-                    *src);
-  const __m128i chk =
-      __lsx_vsadd_b(__lsx_vshuf_b((__m128i)check_values, (__m128i)check_values,
-                                  (__m128i)check_hash),
-                    *src);
-  unsigned int mask = __lsx_vpickve2gr_hu(__lsx_vmskltz_b(chk), 0);
+  __m256i out = __lasx_xvsadd_b(
+      __lasx_xvshuf_b(delta_values, delta_values, delta_hash), *src);
+  __m256i chk = __lasx_xvsadd_b(
+      __lasx_xvshuf_b(check_values, check_values, check_hash), *src);
+  __m256i chk_ltz = __lasx_xvmskltz_b(chk);
+  unsigned int mask = __lasx_xvpickve2gr_wu(chk_ltz, 0);
+  mask = mask | (__lsx_vpickve2gr_hu(lasx_extracti128_hi(chk_ltz), 0) << 16);
   if (mask) {
-    __m128i ascii_space = __lsx_vseq_b(__lsx_vshuf_b((__m128i)ascii_space_tbl,
-                                                     (__m128i)ascii_space_tbl,
-                                                     (__m128i)asso_index),
-                                       *src);
-    *error |=
-        (mask != __lsx_vpickve2gr_hu(__lsx_vmskltz_b((__m128i)ascii_space), 0));
+    __m256i ascii_space = __lasx_xvseq_b(
+        __lasx_xvshuf_b(ascii_space_tbl, ascii_space_tbl, asso_index), *src);
+    __m256i ascii_space_ltz = __lasx_xvmskltz_b(ascii_space);
+    unsigned int ascii_space_mask = __lasx_xvpickve2gr_wu(ascii_space_ltz, 0);
+    ascii_space_mask =
+        ascii_space_mask |
+        (__lsx_vpickve2gr_hu(lasx_extracti128_hi(ascii_space_ltz), 0) << 16);
+    *error |= (mask != ascii_space_mask);
   }
 
   *src = out;
-  return (uint16_t)mask;
+  return (uint32_t)mask;
 }
 
 template <bool base64_url, bool default_or_url>
@@ -19266,18 +19139,12 @@ static inline uint64_t to_base64_mask(block64 *b, bool *error) {
       to_base64_mask<base64_url, default_or_url>(&b->chunks[0], error);
   uint64_t m1 =
       to_base64_mask<base64_url, default_or_url>(&b->chunks[1], error);
-  uint64_t m2 =
-      to_base64_mask<base64_url, default_or_url>(&b->chunks[2], error);
-  uint64_t m3 =
-      to_base64_mask<base64_url, default_or_url>(&b->chunks[3], error);
-  return m0 | (m1 << 16) | (m2 << 32) | (m3 << 48);
+  return m0 | (m1 << 32);
 }
 
 static inline void copy_block(block64 *b, char *output) {
-  __lsx_vst(b->chunks[0], reinterpret_cast<__m128i *>(output), 0);
-  __lsx_vst(b->chunks[1], reinterpret_cast<__m128i *>(output), 16);
-  __lsx_vst(b->chunks[2], reinterpret_cast<__m128i *>(output), 32);
-  __lsx_vst(b->chunks[3], reinterpret_cast<__m128i *>(output), 48);
+  __lasx_xvst(b->chunks[0], reinterpret_cast<__m256i *>(output), 0);
+  __lasx_xvst(b->chunks[1], reinterpret_cast<__m256i *>(output), 32);
 }
 
 static inline uint64_t compress_block(block64 *b, uint64_t mask, char *output) {
@@ -19285,84 +19152,150 @@ static inline uint64_t compress_block(block64 *b, uint64_t mask, char *output) {
   uint64_t count =
       __lsx_vpickve2gr_d(__lsx_vpcnt_h(__lsx_vreplgr2vr_d(nmask)), 0);
   uint16_t *count_ptr = (uint16_t *)&count;
-  compress(b->chunks[0], uint16_t(mask), output);
-  compress(b->chunks[1], uint16_t(mask >> 16), output + count_ptr[0]);
-  compress(b->chunks[2], uint16_t(mask >> 32),
+  compress(lasx_extracti128_lo(b->chunks[0]), uint16_t(mask), output);
+  compress(lasx_extracti128_hi(b->chunks[0]), uint16_t(mask >> 16),
+           output + count_ptr[0]);
+  compress(lasx_extracti128_lo(b->chunks[1]), uint16_t(mask >> 32),
            output + count_ptr[0] + count_ptr[1]);
-  compress(b->chunks[3], uint16_t(mask >> 48),
+  compress(lasx_extracti128_hi(b->chunks[1]), uint16_t(mask >> 48),
            output + count_ptr[0] + count_ptr[1] + count_ptr[2]);
   return count_ones(nmask);
 }
 
+template <typename T> bool is_power_of_two(T x) { return (x & (x - 1)) == 0; }
+
+inline size_t compress_block_single(block64 *b, uint64_t mask, char *output) {
+  const size_t pos64 = trailing_zeroes(mask);
+  const int8_t pos = pos64 & 0xf;
+
+  // Predefine the index vector
+  const v16u8 v1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+
+  switch (pos64 >> 4) {
+  case 0b00: {
+    const __m128i lane0 = lasx_extracti128_lo(b->chunks[0]);
+    const __m128i lane1 = lasx_extracti128_hi(b->chunks[0]);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1); // v1 > v0
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(lane0, lane0, sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 0 * 16), 0);
+    __lsx_vst(lane1, reinterpret_cast<__m128i *>(output + 1 * 16 - 1), 0);
+    __lasx_xvst(b->chunks[1], reinterpret_cast<__m256i *>(output + 2 * 16 - 1),
+                0);
+  } break;
+  case 0b01: {
+    const __m128i lane0 = lasx_extracti128_lo(b->chunks[0]);
+    const __m128i lane1 = lasx_extracti128_hi(b->chunks[0]);
+    __lsx_vst(lane0, reinterpret_cast<__m128i *>(output + 0 * 16), 0);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1);
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(lane1, lane1, sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 1 * 16), 0);
+    __lasx_xvst(b->chunks[1], reinterpret_cast<__m256i *>(output + 2 * 16 - 1),
+                0);
+  } break;
+  case 0b10: {
+    __lasx_xvst(b->chunks[0], reinterpret_cast<__m256i *>(output + 0 * 16), 0);
+
+    const __m128i lane2 = lasx_extracti128_lo(b->chunks[1]);
+    const __m128i lane3 = lasx_extracti128_hi(b->chunks[1]);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1);
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(lane2, lane2, sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 2 * 16), 0);
+    __lsx_vst(lane3, reinterpret_cast<__m128i *>(output + 3 * 16 - 1), 0);
+  } break;
+  case 0b11: {
+    __lasx_xvst(b->chunks[0], reinterpret_cast<__m256i *>(output + 0 * 16), 0);
+    __lsx_vst(lasx_extracti128_lo(b->chunks[1]),
+              reinterpret_cast<__m128i *>(output + 2 * 16), 0);
+
+    const __m128i lane3 = lasx_extracti128_hi(b->chunks[1]);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1);
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(lane3, lane3, sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 3 * 16), 0);
+  } break;
+  }
+  return 63;
+}
+
 // The caller of this function is responsible to ensure that there are 64 bytes
 // available from reading at src. The data is read into a block64 structure.
 static inline void load_block(block64 *b, const char *src) {
-  b->chunks[0] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 0);
-  b->chunks[1] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 16);
-  b->chunks[2] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 32);
-  b->chunks[3] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 48);
+  b->chunks[0] = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0);
+  b->chunks[1] = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32);
 }
 
 // The caller of this function is responsible to ensure that there are 128 bytes
 // available from reading at src. The data is read into a block64 structure.
 static inline void load_block(block64 *b, const char16_t *src) {
-  __m128i m1 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 0);
-  __m128i m2 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 16);
-  __m128i m3 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 32);
-  __m128i m4 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 48);
-  __m128i m5 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 64);
-  __m128i m6 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 80);
-  __m128i m7 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 96);
-  __m128i m8 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 112);
-  b->chunks[0] = __lsx_vssrlni_bu_h(m2, m1, 0);
-  b->chunks[1] = __lsx_vssrlni_bu_h(m4, m3, 0);
-  b->chunks[2] = __lsx_vssrlni_bu_h(m6, m5, 0);
-  b->chunks[3] = __lsx_vssrlni_bu_h(m8, m7, 0);
+  __m256i m1 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0);
+  __m256i m2 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32);
+  __m256i m3 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 64);
+  __m256i m4 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 96);
+  b->chunks[0] = __lasx_xvpermi_d(__lasx_xvssrlni_bu_h(m2, m1, 0), 0b11011000);
+  b->chunks[1] = __lasx_xvpermi_d(__lasx_xvssrlni_bu_h(m4, m3, 0), 0b11011000);
 }
 
-static inline void base64_decode(char *out, __m128i str) {
-  __m128i t0 = __lsx_vor_v(
-      __lsx_vslli_w(str, 26),
-      __lsx_vslli_w(__lsx_vand_v(str, lsx_splat_u32(0x0000FF00)), 12));
-  __m128i t1 = __lsx_vsrli_w(__lsx_vand_v(str, lsx_splat_u32(0x003F0000)), 2);
-  __m128i t2 = __lsx_vor_v(t0, t1);
-  __m128i t3 = __lsx_vor_v(t2, __lsx_vsrli_w(str, 16));
-  const v16u8 pack_shuffle = {3, 2,  1,  7,  6, 5, 11, 10,
-                              9, 15, 14, 13, 0, 0, 0,  0};
-  t3 = __lsx_vshuf_b(t3, t3, (__m128i)pack_shuffle);
+static inline void base64_decode(char *out, __m256i str) {
+  __m256i t0 = __lasx_xvor_v(
+      __lasx_xvslli_w(str, 26),
+      __lasx_xvslli_w(__lasx_xvand_v(str, lasx_splat_u32(0x0000ff00)), 12));
+  __m256i t1 =
+      __lasx_xvsrli_w(__lasx_xvand_v(str, lasx_splat_u32(0x003f0000)), 2);
+  __m256i t2 = __lasx_xvor_v(t0, t1);
+  __m256i t3 = __lasx_xvor_v(t2, __lasx_xvsrli_w(str, 16));
+  __m256i pack_shuffle = ____m256i(
+      (__m128i)v16u8{3, 2, 1, 7, 6, 5, 11, 10, 9, 15, 14, 13, 0, 0, 0, 0});
+  t3 = __lasx_xvshuf_b(t3, t3, (__m256i)pack_shuffle);
 
   // Store the output:
-  // we only need 12.
-  __lsx_vstelm_d(t3, out, 0, 0);
-  __lsx_vstelm_w(t3, out + 8, 0, 2);
+  __lsx_vst(lasx_extracti128_lo(t3), out, 0);
+  __lsx_vst(lasx_extracti128_hi(t3), out, 12);
 }
 // decode 64 bytes and output 48 bytes
 static inline void base64_decode_block(char *out, const char *src) {
-  base64_decode(out, __lsx_vld(reinterpret_cast<const __m128i *>(src), 0));
-  base64_decode(out + 12,
-                __lsx_vld(reinterpret_cast<const __m128i *>(src), 16));
+  base64_decode(out, __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0));
   base64_decode(out + 24,
-                __lsx_vld(reinterpret_cast<const __m128i *>(src), 32));
-  base64_decode(out + 36,
-                __lsx_vld(reinterpret_cast<const __m128i *>(src), 48));
+                __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32));
 }
+
 static inline void base64_decode_block_safe(char *out, const char *src) {
-  base64_decode_block(out, src);
+  base64_decode(out, __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0));
+  alignas(32) char buffer[32];
+  base64_decode(buffer,
+                __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32));
+  std::memcpy(out + 24, buffer, 24);
 }
+
 static inline void base64_decode_block(char *out, block64 *b) {
   base64_decode(out, b->chunks[0]);
-  base64_decode(out + 12, b->chunks[1]);
-  base64_decode(out + 24, b->chunks[2]);
-  base64_decode(out + 36, b->chunks[3]);
+  base64_decode(out + 24, b->chunks[1]);
 }
 static inline void base64_decode_block_safe(char *out, block64 *b) {
-  base64_decode_block(out, b);
+  base64_decode(out, b->chunks[0]);
+  alignas(32) char buffer[32];
+  base64_decode(buffer, b->chunks[1]);
+  std::memcpy(out + 24, buffer, 24);
 }
 
 template <bool base64_url, bool ignore_garbage, bool default_or_url,
-          typename char_type>
+          typename chartype>
 full_result
-compress_decode_base64(char *dst, const char_type *src, size_t srclen,
+compress_decode_base64(char *dst, const chartype *src, size_t srclen,
                        base64_options options,
                        last_chunk_handling_options last_chunk_options) {
   const uint8_t *to_base64 =
@@ -19380,15 +19313,19 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
     }
     return {SUCCESS, full_input_length, 0};
   }
-  const char_type *const srcinit = src;
+  char *end_of_safe_64byte_zone =
+      (srclen + 3) / 4 * 3 >= 63 ? dst + (srclen + 3) / 4 * 3 - 63 : dst;
+
+  const chartype *const srcinit = src;
   const char *const dstinit = dst;
-  const char_type *const srcend = src + srclen;
+  const chartype *const srcend = src + srclen;
 
-  constexpr size_t block_size = 10;
+  constexpr size_t block_size = 6;
+  static_assert(block_size >= 2, "block_size must be at least two");
   char buffer[block_size * 64];
   char *bufferptr = buffer;
   if (srclen >= 64) {
-    const char_type *const srcend64 = src + srclen - 64;
+    const chartype *const srcend64 = src + srclen - 64;
     while (src <= srcend64) {
       block64 b;
       load_block(&b, src);
@@ -19396,48 +19333,56 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
       bool error = false;
       uint64_t badcharmask =
           to_base64_mask<base64_url, default_or_url>(&b, &error);
-      if (badcharmask) {
-        if (error && !ignore_garbage) {
-          src -= 64;
-          while (src < srcend && scalar::base64::is_eight_byte(*src) &&
-                 to_base64[uint8_t(*src)] <= 64) {
-            src++;
-          }
-          if (src < srcend) {
-            // should never happen
-          }
-          return {error_code::INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-                  size_t(dst - dstinit)};
+      if (error && !ignore_garbage) {
+        src -= 64;
+        while (src < srcend && scalar::base64::is_eight_byte(*src) &&
+               to_base64[uint8_t(*src)] <= 64) {
+          src++;
         }
+        return {error_code::INVALID_BASE64_CHARACTER, size_t(src - srcinit),
+                size_t(dst - dstinit)};
       }
-
       if (badcharmask != 0) {
-        // optimization opportunity: check for simple masks like those made of
-        // continuous 1s followed by continuous 0s. And masks containing a
-        // single bad character.
-        bufferptr += compress_block(&b, badcharmask, bufferptr);
-      } else {
-        // optimization opportunity: if bufferptr == buffer and mask == 0, we
-        // can avoid the call to compress_block and decode directly.
+        if (is_power_of_two(badcharmask)) {
+          bufferptr += compress_block_single(&b, badcharmask, bufferptr);
+        } else {
+          bufferptr += compress_block(&b, badcharmask, bufferptr);
+        }
+      } else if (bufferptr != buffer) {
         copy_block(&b, bufferptr);
         bufferptr += 64;
+      } else {
+        if (dst >= end_of_safe_64byte_zone) {
+          base64_decode_block_safe(dst, &b);
+        } else {
+          base64_decode_block(dst, &b);
+        }
+        dst += 48;
       }
       if (bufferptr >= (block_size - 1) * 64 + buffer) {
-        for (size_t i = 0; i < (block_size - 1); i++) {
+        for (size_t i = 0; i < (block_size - 2); i++) {
           base64_decode_block(dst, buffer + i * 64);
           dst += 48;
         }
+        if (dst >= end_of_safe_64byte_zone) {
+          base64_decode_block_safe(dst, buffer + (block_size - 2) * 64);
+        } else {
+          base64_decode_block(dst, buffer + (block_size - 2) * 64);
+        }
+        dst += 48;
         std::memcpy(buffer, buffer + (block_size - 1) * 64,
                     64); // 64 might be too much
         bufferptr -= (block_size - 1) * 64;
       }
     }
   }
+
   char *buffer_start = buffer;
   // Optimization note: if this is almost full, then it is worth our
   // time, otherwise, we should just decode directly.
   int last_block = (int)((bufferptr - buffer_start) % 64);
   if (last_block != 0 && srcend - src + last_block >= 64) {
+
     while ((bufferptr - buffer_start) % 64 != 0 && src < srcend) {
       uint8_t val = to_base64[uint8_t(*src)];
       *bufferptr = char(val);
@@ -19452,7 +19397,11 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
   }
 
   for (; buffer_start + 64 <= bufferptr; buffer_start += 64) {
-    base64_decode_block(dst, buffer_start);
+    if (dst >= end_of_safe_64byte_zone) {
+      base64_decode_block_safe(dst, buffer_start);
+    } else {
+      base64_decode_block(dst, buffer_start);
+    }
     dst += 48;
   }
   if ((bufferptr - buffer_start) % 64 != 0) {
@@ -19462,6 +19411,7 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
                          (uint32_t(uint8_t(buffer_start[2])) << 1 * 6) +
                          (uint32_t(uint8_t(buffer_start[3])) << 0 * 6))
                         << 8;
+      // lasx is little-endian
       triple = scalar::u32_swap_bytes(triple);
       std::memcpy(dst, &triple, 4);
 
@@ -19474,6 +19424,7 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
                          (uint32_t(uint8_t(buffer_start[2])) << 1 * 6) +
                          (uint32_t(uint8_t(buffer_start[3])) << 0 * 6))
                         << 8;
+      // lasx is little-endian
       triple = scalar::u32_swap_bytes(triple);
       std::memcpy(dst, &triple, 3);
 
@@ -19533,22 +19484,24 @@ compress_decode_base64(char *dst, const char_type *src, size_t srclen,
   }
   return {SUCCESS, srclen, size_t(dst - dstinit)};
 }
-/* end file src/lsx/lsx_base64.cpp */
-/* begin file src/lsx/lsx_find.cpp */
+/* end file src/lasx/lasx_base64.cpp */
+/* begin file src/lasx/lasx_find.cpp */
 simdutf_really_inline const char *util_find(const char *start, const char *end,
                                             char character) noexcept {
   if (start >= end)
     return end;
 
-  const int step = 16;
-  __m128i char_vec = __lsx_vreplgr2vr_b(static_cast<uint8_t>(character));
+  const int step = 32;
+  __m256i char_vec = __lasx_xvreplgr2vr_b(static_cast<uint16_t>(character));
 
   while (end - start >= step) {
-    __m128i data = __lsx_vld(reinterpret_cast<const __m128i *>(start), 0);
-    __m128i cmp = __lsx_vseq_b(data, char_vec);
-    if (__lsx_bnz_v(cmp)) {
-      uint16_t mask =
-          static_cast<uint16_t>(__lsx_vpickve2gr_hu(__lsx_vmsknz_b(cmp), 0));
+    __m256i data = __lasx_xvld(reinterpret_cast<const __m256i *>(start), 0);
+    __m256i cmp = __lasx_xvseq_b(data, char_vec);
+    if (__lasx_xbnz_v(cmp)) {
+      __m256i res = __lasx_xvmsknz_b(cmp);
+      uint32_t mask0 = __lasx_xvpickve2gr_wu(res, 0);
+      uint32_t mask1 = __lasx_xvpickve2gr_wu(res, 4);
+      uint32_t mask = (mask0 | (mask1 << 16));
       return start + trailing_zeroes(mask);
     }
 
@@ -19571,15 +19524,17 @@ simdutf_really_inline const char16_t *util_find(const char16_t *start,
   if (start >= end)
     return end;
 
-  const int step = 8;
-  __m128i char_vec = __lsx_vreplgr2vr_h(static_cast<uint16_t>(character));
+  const int step = 16;
+  __m256i char_vec = __lasx_xvreplgr2vr_h(static_cast<uint16_t>(character));
 
   while (end - start >= step) {
-    __m128i data = __lsx_vld(reinterpret_cast<const __m128i *>(start), 0);
-    __m128i cmp = __lsx_vseq_h(data, char_vec);
-    if (__lsx_bnz_v(cmp)) {
-      uint16_t mask =
-          static_cast<uint16_t>(__lsx_vpickve2gr_hu(__lsx_vmsknz_b(cmp), 0));
+    __m256i data = __lasx_xvld(reinterpret_cast<const __m256i *>(start), 0);
+    __m256i cmp = __lasx_xvseq_h(data, char_vec);
+    if (__lasx_xbnz_v(cmp)) {
+      __m256i res = __lasx_xvmsknz_b(cmp);
+      uint32_t mask0 = __lasx_xvpickve2gr_wu(res, 0);
+      uint32_t mask1 = __lasx_xvpickve2gr_wu(res, 4);
+      uint32_t mask = (mask0 | (mask1 << 16));
       return start + trailing_zeroes(mask) / 2;
     }
 
@@ -19595,15 +19550,15 @@ simdutf_really_inline const char16_t *util_find(const char16_t *start,
 
   return end;
 }
-/* end file src/lsx/lsx_find.cpp */
+/* end file src/lasx/lasx_find.cpp */
 
 } // namespace
-} // namespace lsx
+} // namespace lasx
 } // namespace simdutf
 
 /* begin file src/generic/buf_block_reader.h */
 namespace simdutf {
-namespace lsx {
+namespace lasx {
 namespace {
 
 // Walks through a buffer in block-sized increments, loading the last part with
@@ -19634,40 +19589,6 @@ template <size_t STEP_SIZE> struct buf_block_reader {
   size_t idx;
 };
 
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text_64(const uint8_t *text) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  in.store(reinterpret_cast<uint8_t *>(buf));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    if (buf[i] < ' ') {
-      buf[i] = '_';
-    }
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-simdutf_unused static char *format_mask(uint64_t mask) {
-  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
-  for (size_t i = 0; i < 64; i++) {
-    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
-  }
-  buf[64] = '\0';
-  return buf;
-}
-
 template <size_t STEP_SIZE>
 simdutf_really_inline
 buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
@@ -19709,15 +19630,81 @@ simdutf_really_inline void buf_block_reader<STEP_SIZE>::advance() {
 }
 
 } // unnamed namespace
-} // namespace lsx
+} // namespace lasx
 } // namespace simdutf
 /* end file src/generic/buf_block_reader.h */
 
+/* begin file src/generic/base64lengths.h */
+namespace simdutf {
+namespace lasx {
+namespace {
+namespace base64_lengths {
+
+simdutf_warn_unused size_t binary_length_from_base64(const char *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 64 <= length; pos += 64) {
+    simd8x64<uint8_t> block(reinterpret_cast<const uint8_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+simdutf_warn_unused size_t binary_length_from_base64(const char16_t *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 32 <= length; pos += 32) {
+    simd16x32<uint16_t> block(reinterpret_cast<const uint16_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char16_t c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+} // namespace base64_lengths
+} // unnamed namespace
+} // namespace lasx
+} // namespace simdutf
+/* end file src/generic/base64lengths.h */
+
 //
 // Implementation-specific overrides
 //
 namespace simdutf {
-namespace lsx {
+namespace lasx {
 
 simdutf_warn_unused result implementation::base64_to_binary(
     const char *input, size_t length, char *output, base64_options options,
@@ -19848,6 +19835,14 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
     return encode_base64<false>(output, input, length, options);
   }
 }
+
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  return scalar::base64::tail_encode_base64_impl<true>(output, input, length,
+                                                       options, line_length);
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return util_find(start, end, character);
@@ -19858,30 +19853,46 @@ const char16_t *implementation::find(const char16_t *start, const char16_t *end,
   return util_find(start, end, character);
 }
 
-} // namespace lsx
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
+} // namespace lasx
 } // namespace simdutf
 
-/* begin file src/simdutf/lsx/end.h */
+/* begin file src/simdutf/lasx/end.h */
 #undef SIMDUTF_SIMD_HAS_UNSIGNED_CMP
-/* end file src/simdutf/lsx/end.h */
-/* end file src/lsx/implementation.cpp */
+
+#if SIMDUTF_CAN_ALWAYS_RUN_LASX
+// nothing needed.
+#else
+SIMDUTF_UNTARGET_REGION
 #endif
-#if SIMDUTF_IMPLEMENTATION_LASX
-/* begin file src/lasx/implementation.cpp */
-/* begin file src/simdutf/lasx/begin.h */
-// redefining SIMDUTF_IMPLEMENTATION to "lasx"
-// #define SIMDUTF_IMPLEMENTATION lasx
+/* end file src/simdutf/lasx/end.h */
+/* end file src/lasx/implementation.cpp */
+#endif
+#if SIMDUTF_IMPLEMENTATION_LSX
+/* begin file src/lsx/implementation.cpp */
+/* begin file src/simdutf/lsx/begin.h */
+// redefining SIMDUTF_IMPLEMENTATION to "lsx"
+// #define SIMDUTF_IMPLEMENTATION lsx
 #define SIMDUTF_SIMD_HAS_UNSIGNED_CMP 1
-/* end file src/simdutf/lasx/begin.h */
+/* end file src/simdutf/lsx/begin.h */
 namespace simdutf {
-namespace lasx {
+namespace lsx {
 namespace {
-#ifndef SIMDUTF_LASX_H
-  #error "lasx.h must be included"
+#ifndef SIMDUTF_LSX_H
+  #error "lsx.h must be included"
 #endif
 using namespace simd;
 
-/* begin file src/lasx/lasx_base64.cpp */
+/* begin file src/lsx/lsx_base64.cpp */
 /**
  * References and further reading:
  *
@@ -19922,118 +19933,100 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
           : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   uint8_t *out = (uint8_t *)dst;
 
-  v32u8 shuf;
-  __m256i v_fc0fc00, v_3f03f0, shift_r, shift_l, base64_tbl0, base64_tbl1,
+  v16u8 shuf;
+  __m128i v_fc0fc00, v_3f03f0, shift_r, shift_l, base64_tbl0, base64_tbl1,
       base64_tbl2, base64_tbl3;
-  if (srclen >= 28) {
-    shuf = v32u8{1, 0, 2, 1, 4, 3, 5, 4, 7, 6, 8, 7, 10, 9, 11, 10,
-                 1, 0, 2, 1, 4, 3, 5, 4, 7, 6, 8, 7, 10, 9, 11, 10};
-
-    v_fc0fc00 = __lasx_xvreplgr2vr_w(uint32_t(0x0fc0fc00));
-    v_3f03f0 = __lasx_xvreplgr2vr_w(uint32_t(0x003f03f0));
-    shift_r = __lasx_xvreplgr2vr_w(uint32_t(0x0006000a));
-    shift_l = __lasx_xvreplgr2vr_w(uint32_t(0x00080004));
-    base64_tbl0 = ____m256i(__lsx_vld(lookup_tbl, 0));
-    base64_tbl1 = ____m256i(__lsx_vld(lookup_tbl, 16));
-    base64_tbl2 = ____m256i(__lsx_vld(lookup_tbl, 32));
-    base64_tbl3 = ____m256i(__lsx_vld(lookup_tbl, 48));
+  if (srclen >= 16) {
+    shuf = v16u8{1, 0, 2, 1, 4, 3, 5, 4, 7, 6, 8, 7, 10, 9, 11, 10};
+    v_fc0fc00 = __lsx_vreplgr2vr_w(uint32_t(0x0fc0fc00));
+    v_3f03f0 = __lsx_vreplgr2vr_w(uint32_t(0x003f03f0));
+    shift_r = __lsx_vreplgr2vr_w(uint32_t(0x0006000a));
+    shift_l = __lsx_vreplgr2vr_w(uint32_t(0x00080004));
+    base64_tbl0 = __lsx_vld(lookup_tbl, 0);
+    base64_tbl1 = __lsx_vld(lookup_tbl, 16);
+    base64_tbl2 = __lsx_vld(lookup_tbl, 32);
+    base64_tbl3 = __lsx_vld(lookup_tbl, 48);
   }
+
   size_t i = 0;
-  for (; i + 100 <= srclen; i += 96) {
-    __m128i in0_lo =
+  for (; i + 52 <= srclen; i += 48) {
+    __m128i in0 =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 0);
-    __m128i in0_hi =
+    __m128i in1 =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 1);
-    __m128i in1_lo =
+    __m128i in2 =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 2);
-    __m128i in1_hi =
+    __m128i in3 =
         __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 3);
-    __m128i in2_lo =
-        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 4);
-    __m128i in2_hi =
-        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 5);
-    __m128i in3_lo =
-        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 6);
-    __m128i in3_hi =
-        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 7);
-
-    __m256i in0 = lasx_set_q(in0_hi, in0_lo);
-    __m256i in1 = lasx_set_q(in1_hi, in1_lo);
-    __m256i in2 = lasx_set_q(in2_hi, in2_lo);
-    __m256i in3 = lasx_set_q(in3_hi, in3_lo);
-
-    in0 = __lasx_xvshuf_b(in0, in0, (__m256i)shuf);
-    in1 = __lasx_xvshuf_b(in1, in1, (__m256i)shuf);
-    in2 = __lasx_xvshuf_b(in2, in2, (__m256i)shuf);
-    in3 = __lasx_xvshuf_b(in3, in3, (__m256i)shuf);
 
-    __m256i t0_0 = __lasx_xvand_v(in0, v_fc0fc00);
-    __m256i t0_1 = __lasx_xvand_v(in1, v_fc0fc00);
-    __m256i t0_2 = __lasx_xvand_v(in2, v_fc0fc00);
-    __m256i t0_3 = __lasx_xvand_v(in3, v_fc0fc00);
+    in0 = __lsx_vshuf_b(in0, in0, (__m128i)shuf);
+    in1 = __lsx_vshuf_b(in1, in1, (__m128i)shuf);
+    in2 = __lsx_vshuf_b(in2, in2, (__m128i)shuf);
+    in3 = __lsx_vshuf_b(in3, in3, (__m128i)shuf);
 
-    __m256i t1_0 = __lasx_xvsrl_h(t0_0, shift_r);
-    __m256i t1_1 = __lasx_xvsrl_h(t0_1, shift_r);
-    __m256i t1_2 = __lasx_xvsrl_h(t0_2, shift_r);
-    __m256i t1_3 = __lasx_xvsrl_h(t0_3, shift_r);
+    __m128i t0_0 = __lsx_vand_v(in0, v_fc0fc00);
+    __m128i t0_1 = __lsx_vand_v(in1, v_fc0fc00);
+    __m128i t0_2 = __lsx_vand_v(in2, v_fc0fc00);
+    __m128i t0_3 = __lsx_vand_v(in3, v_fc0fc00);
 
-    __m256i t2_0 = __lasx_xvand_v(in0, v_3f03f0);
-    __m256i t2_1 = __lasx_xvand_v(in1, v_3f03f0);
-    __m256i t2_2 = __lasx_xvand_v(in2, v_3f03f0);
-    __m256i t2_3 = __lasx_xvand_v(in3, v_3f03f0);
+    __m128i t1_0 = __lsx_vsrl_h(t0_0, shift_r);
+    __m128i t1_1 = __lsx_vsrl_h(t0_1, shift_r);
+    __m128i t1_2 = __lsx_vsrl_h(t0_2, shift_r);
+    __m128i t1_3 = __lsx_vsrl_h(t0_3, shift_r);
 
-    __m256i t3_0 = __lasx_xvsll_h(t2_0, shift_l);
-    __m256i t3_1 = __lasx_xvsll_h(t2_1, shift_l);
-    __m256i t3_2 = __lasx_xvsll_h(t2_2, shift_l);
-    __m256i t3_3 = __lasx_xvsll_h(t2_3, shift_l);
+    __m128i t2_0 = __lsx_vand_v(in0, v_3f03f0);
+    __m128i t2_1 = __lsx_vand_v(in1, v_3f03f0);
+    __m128i t2_2 = __lsx_vand_v(in2, v_3f03f0);
+    __m128i t2_3 = __lsx_vand_v(in3, v_3f03f0);
 
-    __m256i input0 = __lasx_xvor_v(t1_0, t3_0);
-    __m256i input0_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input0);
-    __m256i input0_shuf1 = __lasx_xvshuf_b(
-        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input0, __lasx_xvldi(32)));
-    __m256i input0_mask = __lasx_xvslei_bu(input0, 31);
-    __m256i input0_result =
-        __lasx_xvbitsel_v(input0_shuf1, input0_shuf0, input0_mask);
-    __lasx_xvst(input0_result, reinterpret_cast<__m256i *>(out), 0);
-    out += 32;
+    __m128i t3_0 = __lsx_vsll_h(t2_0, shift_l);
+    __m128i t3_1 = __lsx_vsll_h(t2_1, shift_l);
+    __m128i t3_2 = __lsx_vsll_h(t2_2, shift_l);
+    __m128i t3_3 = __lsx_vsll_h(t2_3, shift_l);
 
-    __m256i input1 = __lasx_xvor_v(t1_1, t3_1);
-    __m256i input1_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input1);
-    __m256i input1_shuf1 = __lasx_xvshuf_b(
-        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input1, __lasx_xvldi(32)));
-    __m256i input1_mask = __lasx_xvslei_bu(input1, 31);
-    __m256i input1_result =
-        __lasx_xvbitsel_v(input1_shuf1, input1_shuf0, input1_mask);
-    __lasx_xvst(input1_result, reinterpret_cast<__m256i *>(out), 0);
-    out += 32;
+    __m128i input0 = __lsx_vor_v(t1_0, t3_0);
+    __m128i input0_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input0);
+    __m128i input0_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
+                                         __lsx_vsub_b(input0, __lsx_vldi(32)));
+    __m128i input0_mask = __lsx_vslei_bu(input0, 31);
+    __m128i input0_result =
+        __lsx_vbitsel_v(input0_shuf1, input0_shuf0, input0_mask);
+    __lsx_vst(input0_result, reinterpret_cast<__m128i *>(out), 0);
+    out += 16;
 
-    __m256i input2 = __lasx_xvor_v(t1_2, t3_2);
-    __m256i input2_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input2);
-    __m256i input2_shuf1 = __lasx_xvshuf_b(
-        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input2, __lasx_xvldi(32)));
-    __m256i input2_mask = __lasx_xvslei_bu(input2, 31);
-    __m256i input2_result =
-        __lasx_xvbitsel_v(input2_shuf1, input2_shuf0, input2_mask);
-    __lasx_xvst(input2_result, reinterpret_cast<__m256i *>(out), 0);
-    out += 32;
+    __m128i input1 = __lsx_vor_v(t1_1, t3_1);
+    __m128i input1_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input1);
+    __m128i input1_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
+                                         __lsx_vsub_b(input1, __lsx_vldi(32)));
+    __m128i input1_mask = __lsx_vslei_bu(input1, 31);
+    __m128i input1_result =
+        __lsx_vbitsel_v(input1_shuf1, input1_shuf0, input1_mask);
+    __lsx_vst(input1_result, reinterpret_cast<__m128i *>(out), 0);
+    out += 16;
 
-    __m256i input3 = __lasx_xvor_v(t1_3, t3_3);
-    __m256i input3_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, input3);
-    __m256i input3_shuf1 = __lasx_xvshuf_b(
-        base64_tbl3, base64_tbl2, __lasx_xvsub_b(input3, __lasx_xvldi(32)));
-    __m256i input3_mask = __lasx_xvslei_bu(input3, 31);
-    __m256i input3_result =
-        __lasx_xvbitsel_v(input3_shuf1, input3_shuf0, input3_mask);
-    __lasx_xvst(input3_result, reinterpret_cast<__m256i *>(out), 0);
-    out += 32;
-  }
-  for (; i + 28 <= srclen; i += 24) {
+    __m128i input2 = __lsx_vor_v(t1_2, t3_2);
+    __m128i input2_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input2);
+    __m128i input2_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
+                                         __lsx_vsub_b(input2, __lsx_vldi(32)));
+    __m128i input2_mask = __lsx_vslei_bu(input2, 31);
+    __m128i input2_result =
+        __lsx_vbitsel_v(input2_shuf1, input2_shuf0, input2_mask);
+    __lsx_vst(input2_result, reinterpret_cast<__m128i *>(out), 0);
+    out += 16;
 
-    __m128i in_lo = __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 0);
-    __m128i in_hi =
-        __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 4 * 3 * 1);
+    __m128i input3 = __lsx_vor_v(t1_3, t3_3);
+    __m128i input3_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, input3);
+    __m128i input3_shuf1 = __lsx_vshuf_b(base64_tbl3, base64_tbl2,
+                                         __lsx_vsub_b(input3, __lsx_vldi(32)));
+    __m128i input3_mask = __lsx_vslei_bu(input3, 31);
+    __m128i input3_result =
+        __lsx_vbitsel_v(input3_shuf1, input3_shuf0, input3_mask);
+    __lsx_vst(input3_result, reinterpret_cast<__m128i *>(out), 0);
+    out += 16;
+  }
+  for (; i + 16 <= srclen; i += 12) {
 
-    __m256i in = lasx_set_q(in_hi, in_lo);
+    __m128i in = __lsx_vld(reinterpret_cast<const __m128i *>(input + i), 0);
 
     // bytes from groups A, B and C are needed in separate 32-bit lanes
     // in = [DDDD|CCCC|BBBB|AAAA]
@@ -20047,32 +20040,33 @@ size_t encode_base64(char *dst, const char *src, size_t srclen,
     //      [bbbbcccc|ccdddddd|aaaaaabb|bbbbcccc]
     //           ^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^
     //                  processed bits
-    in = __lasx_xvshuf_b(in, in, (__m256i)shuf);
+    in = __lsx_vshuf_b(in, in, (__m128i)shuf);
 
     // unpacking
     // t0    = [0000cccc|cc000000|aaaaaa00|00000000]
-    __m256i t0 = __lasx_xvand_v(in, v_fc0fc00);
+    __m128i t0 = __lsx_vand_v(in, v_fc0fc00);
     // t1    = [00000000|00cccccc|00000000|00aaaaaa]
     //          ((c >> 6),  (a >> 10))
-    __m256i t1 = __lasx_xvsrl_h(t0, shift_r);
+    __m128i t1 = __lsx_vsrl_h(t0, shift_r);
 
     // t2    = [00000000|00dddddd|000000bb|bbbb0000]
-    __m256i t2 = __lasx_xvand_v(in, v_3f03f0);
+    __m128i t2 = __lsx_vand_v(in, v_3f03f0);
     // t3    = [00dddddd|00000000|00bbbbbb|00000000]
     //          ((d << 8), (b << 4))
-    __m256i t3 = __lasx_xvsll_h(t2, shift_l);
+    __m128i t3 = __lsx_vsll_h(t2, shift_l);
 
     // res   = [00dddddd|00cccccc|00bbbbbb|00aaaaaa] = t1 | t3
-    __m256i indices = __lasx_xvor_v(t1, t3);
+    __m128i indices = __lsx_vor_v(t1, t3);
 
-    __m256i indices_shuf0 = __lasx_xvshuf_b(base64_tbl1, base64_tbl0, indices);
-    __m256i indices_shuf1 = __lasx_xvshuf_b(
-        base64_tbl3, base64_tbl2, __lasx_xvsub_b(indices, __lasx_xvldi(32)));
-    __m256i indices_mask = __lasx_xvslei_bu(indices, 31);
-    __m256i indices_result =
-        __lasx_xvbitsel_v(indices_shuf1, indices_shuf0, indices_mask);
-    __lasx_xvst(indices_result, reinterpret_cast<__m256i *>(out), 0);
-    out += 32;
+    __m128i indices_shuf0 = __lsx_vshuf_b(base64_tbl1, base64_tbl0, indices);
+    __m128i indices_shuf1 = __lsx_vshuf_b(
+        base64_tbl3, base64_tbl2, __lsx_vsub_b(indices, __lsx_vldi(32)));
+    __m128i indices_mask = __lsx_vslei_bu(indices, 31);
+    __m128i indices_result =
+        __lsx_vbitsel_v(indices_shuf1, indices_shuf0, indices_mask);
+
+    __lsx_vst(indices_result, reinterpret_cast<__m128i *>(out), 0);
+    out += 16;
   }
 
   return i / 3 * 4 + scalar::base64::tail_encode_base64((char *)out, src + i,
@@ -20096,7 +20090,7 @@ static inline void compress(__m128i data, uint16_t mask, char *output) {
                     tables::base64::thintable_epi8[mask2]};
 
   // we increment by 0x08 the second half of the mask
-  const v4u32 hi = {0, 0, 0x08080808, 0x08080808};
+  v4u32 hi = {0, 0, 0x08080808, 0x08080808};
   __m128i shufmask1 = __lsx_vadd_b((__m128i)shufmask, (__m128i)hi);
 
   // this is the version "nearly pruned"
@@ -20118,111 +20112,115 @@ static inline void compress(__m128i data, uint16_t mask, char *output) {
 }
 
 struct block64 {
-  __m256i chunks[2];
+  __m128i chunks[4];
 };
 
 template <bool base64_url, bool default_or_url>
-static inline uint32_t to_base64_mask(__m256i *src, bool *error) {
-  __m256i ascii_space_tbl =
-      ____m256i((__m128i)v16u8{0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-                               0x9, 0xa, 0x0, 0xc, 0xd, 0x0, 0x0});
+static inline uint16_t to_base64_mask(__m128i *src, bool *error) {
+  const v16u8 ascii_space_tbl = {0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                                 0x0,  0x9, 0xa, 0x0, 0xc, 0xd, 0x0, 0x0};
   // credit: aqrit
-  __m256i delta_asso;
+  /*
+  '0'(0x30)-'9'(0x39) => delta_values_index = 4
+  'A'(0x41)-'Z'(0x5a) => delta_values_index = 4/5/12(4+8)
+  'a'(0x61)-'z'(0x7a) => delta_values_index = 6/7/14(6+8)
+  '+'(0x2b)           => delta_values_index = 3
+  '/'(0x2f)           => delta_values_index = 2+8 = 10
+  '-'(0x2d)           => delta_values_index = 2+8 = 10
+  '_'(0x5f)           => delta_values_index = 5+8 = 13
+  */
+  v16u8 delta_asso;
   if (default_or_url) {
-    delta_asso =
-        ____m256i((__m128i)v16u8{0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0,
-                                 0x0, 0x0, 0x0, 0x0, 0x11, 0x0, 0x16});
+    delta_asso = v16u8{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x00, 0x16};
   } else {
-    delta_asso =
-        ____m256i((__m128i)v16u8{0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0,
-                                 0x0, 0x0, 0x0, 0x0, 0xF, 0x0, 0xF});
+    delta_asso = v16u8{0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
+                       0x0, 0x0, 0x0, 0x0, 0x0, 0xF, 0x0, 0xF};
   }
-  __m256i delta_values;
+  v16i8 delta_values;
   if (default_or_url) {
-    delta_values = ____m256i(
-        (__m128i)v16i8{int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0x13),
-                       int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
-                       int8_t(0xB9), int8_t(0x00), int8_t(0xFF), int8_t(0x11),
-                       int8_t(0xFF), int8_t(0xBF), int8_t(0x10), int8_t(0xB9)});
+    delta_values =
+        v16i8{int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0x13),
+              int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
+              int8_t(0xB9), int8_t(0x00), int8_t(0xFF), int8_t(0x11),
+              int8_t(0xFF), int8_t(0xBF), int8_t(0x10), int8_t(0xB9)};
   } else if (base64_url) {
-    delta_values = ____m256i(
-        (__m128i)v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
-                       int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
-                       int8_t(0xB9), int8_t(0x00), int8_t(0x11), int8_t(0xC3),
-                       int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0xB9)});
+    delta_values =
+        v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
+              int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
+              int8_t(0xB9), int8_t(0x00), int8_t(0x11), int8_t(0xC3),
+              int8_t(0xBF), int8_t(0xE0), int8_t(0xB9), int8_t(0xB9)};
   } else {
-    delta_values = ____m256i(
-        (__m128i)v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
-                       int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
-                       int8_t(0xB9), int8_t(0x00), int8_t(0x10), int8_t(0xC3),
-                       int8_t(0xBF), int8_t(0xBF), int8_t(0xB9), int8_t(0xB9)});
+    delta_values =
+        v16i8{int8_t(0x00), int8_t(0x00), int8_t(0x00), int8_t(0x13),
+              int8_t(0x04), int8_t(0xBF), int8_t(0xBF), int8_t(0xB9),
+              int8_t(0xB9), int8_t(0x00), int8_t(0x10), int8_t(0xC3),
+              int8_t(0xBF), int8_t(0xBF), int8_t(0xB9), int8_t(0xB9)};
   }
 
-  __m256i check_asso;
+  v16u8 check_asso;
   if (default_or_url) {
-    check_asso = ____m256i((__m128i)v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01,
-                                          0x01, 0x01, 0x01, 0x01, 0x03, 0x07,
-                                          0x0B, 0x0E, 0x0B, 0x06});
-
+    check_asso = v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                       0x01, 0x01, 0x03, 0x07, 0x0B, 0x0E, 0x0B, 0x06};
   } else if (base64_url) {
-    check_asso = ____m256i((__m128i)v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01,
-                                          0x01, 0x01, 0x01, 0x01, 0x03, 0x07,
-                                          0x0B, 0x06, 0x0B, 0x12});
+    check_asso = v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                       0x01, 0x01, 0x03, 0x07, 0x0B, 0x06, 0x0B, 0x12};
   } else {
-    check_asso = ____m256i((__m128i)v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01,
-                                          0x01, 0x01, 0x01, 0x01, 0x03, 0x07,
-                                          0x0B, 0x0B, 0x0B, 0x0F});
+    check_asso = v16u8{0x0D, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+                       0x01, 0x01, 0x03, 0x07, 0x0B, 0x0B, 0x0B, 0x0F};
   }
 
-  __m256i check_values;
+  v16i8 check_values;
   if (default_or_url) {
-
-    check_values = ____m256i(
-        (__m128i)v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
-                       int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
-                       int8_t(0xB5), int8_t(0xA1), int8_t(0x00), int8_t(0x80),
-                       int8_t(0x00), int8_t(0x80), int8_t(0x00), int8_t(0x80)});
+    check_values =
+        v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
+              int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
+              int8_t(0xB5), int8_t(0xA1), int8_t(0x00), int8_t(0x80),
+              int8_t(0x00), int8_t(0x80), int8_t(0x00), int8_t(0x80)};
   } else if (base64_url) {
-    check_values = ____m256i(
-        (__m128i)v16i8{int8_t(0x0), int8_t(0x80), int8_t(0x80), int8_t(0x80),
-                       int8_t(0xCF), int8_t(0xBF), int8_t(0xD3), int8_t(0xA6),
-                       int8_t(0xB5), int8_t(0x86), int8_t(0xD0), int8_t(0x80),
-                       int8_t(0xB0), int8_t(0x80), int8_t(0x0), int8_t(0x0)});
+    check_values = v16i8{int8_t(0x0),  int8_t(0x80), int8_t(0x80), int8_t(0x80),
+                         int8_t(0xCF), int8_t(0xBF), int8_t(0xD3), int8_t(0xA6),
+                         int8_t(0xB5), int8_t(0x86), int8_t(0xD0), int8_t(0x80),
+                         int8_t(0xB0), int8_t(0x80), int8_t(0x0),  int8_t(0x0)};
   } else {
-    check_values = ____m256i(
-        (__m128i)v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
-                       int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
-                       int8_t(0xB5), int8_t(0x86), int8_t(0xD1), int8_t(0x80),
-                       int8_t(0xB1), int8_t(0x80), int8_t(0x91), int8_t(0x80)});
+    check_values =
+        v16i8{int8_t(0x80), int8_t(0x80), int8_t(0x80), int8_t(0x80),
+              int8_t(0xCF), int8_t(0xBF), int8_t(0xD5), int8_t(0xA6),
+              int8_t(0xB5), int8_t(0x86), int8_t(0xD1), int8_t(0x80),
+              int8_t(0xB1), int8_t(0x80), int8_t(0x91), int8_t(0x80)};
   }
 
-  __m256i shifted = __lasx_xvsrli_b(*src, 3);
-  __m256i asso_index = __lasx_xvand_v(*src, __lasx_xvldi(0xF));
-  __m256i delta_hash = __lasx_xvavgr_bu(
-      __lasx_xvshuf_b(delta_asso, delta_asso, asso_index), shifted);
-  __m256i check_hash = __lasx_xvavgr_bu(
-      __lasx_xvshuf_b(check_asso, check_asso, asso_index), shifted);
+  const __m128i shifted = __lsx_vsrli_b(*src, 3);
+  __m128i asso_index = __lsx_vand_v(*src, __lsx_vldi(0xF));
+  const __m128i delta_hash =
+      __lsx_vavgr_bu(__lsx_vshuf_b((__m128i)delta_asso, (__m128i)delta_asso,
+                                   (__m128i)asso_index),
+                     shifted);
+  const __m128i check_hash =
+      __lsx_vavgr_bu(__lsx_vshuf_b((__m128i)check_asso, (__m128i)check_asso,
+                                   (__m128i)asso_index),
+                     shifted);
 
-  __m256i out = __lasx_xvsadd_b(
-      __lasx_xvshuf_b(delta_values, delta_values, delta_hash), *src);
-  __m256i chk = __lasx_xvsadd_b(
-      __lasx_xvshuf_b(check_values, check_values, check_hash), *src);
-  __m256i chk_ltz = __lasx_xvmskltz_b(chk);
-  unsigned int mask = __lasx_xvpickve2gr_wu(chk_ltz, 0);
-  mask = mask | (__lsx_vpickve2gr_hu(lasx_extracti128_hi(chk_ltz), 0) << 16);
+  const __m128i out =
+      __lsx_vsadd_b(__lsx_vshuf_b((__m128i)delta_values, (__m128i)delta_values,
+                                  (__m128i)delta_hash),
+                    *src);
+  const __m128i chk =
+      __lsx_vsadd_b(__lsx_vshuf_b((__m128i)check_values, (__m128i)check_values,
+                                  (__m128i)check_hash),
+                    *src);
+  unsigned int mask = __lsx_vpickve2gr_hu(__lsx_vmskltz_b(chk), 0);
   if (mask) {
-    __m256i ascii_space = __lasx_xvseq_b(
-        __lasx_xvshuf_b(ascii_space_tbl, ascii_space_tbl, asso_index), *src);
-    __m256i ascii_space_ltz = __lasx_xvmskltz_b(ascii_space);
-    unsigned int ascii_space_mask = __lasx_xvpickve2gr_wu(ascii_space_ltz, 0);
-    ascii_space_mask =
-        ascii_space_mask |
-        (__lsx_vpickve2gr_hu(lasx_extracti128_hi(ascii_space_ltz), 0) << 16);
-    *error |= (mask != ascii_space_mask);
+    __m128i ascii_space = __lsx_vseq_b(__lsx_vshuf_b((__m128i)ascii_space_tbl,
+                                                     (__m128i)ascii_space_tbl,
+                                                     (__m128i)asso_index),
+                                       *src);
+    *error |=
+        (mask != __lsx_vpickve2gr_hu(__lsx_vmskltz_b((__m128i)ascii_space), 0));
   }
 
   *src = out;
-  return (uint32_t)mask;
+  return (uint16_t)mask;
 }
 
 template <bool base64_url, bool default_or_url>
@@ -20232,12 +20230,18 @@ static inline uint64_t to_base64_mask(block64 *b, bool *error) {
       to_base64_mask<base64_url, default_or_url>(&b->chunks[0], error);
   uint64_t m1 =
       to_base64_mask<base64_url, default_or_url>(&b->chunks[1], error);
-  return m0 | (m1 << 32);
+  uint64_t m2 =
+      to_base64_mask<base64_url, default_or_url>(&b->chunks[2], error);
+  uint64_t m3 =
+      to_base64_mask<base64_url, default_or_url>(&b->chunks[3], error);
+  return m0 | (m1 << 16) | (m2 << 32) | (m3 << 48);
 }
 
 static inline void copy_block(block64 *b, char *output) {
-  __lasx_xvst(b->chunks[0], reinterpret_cast<__m256i *>(output), 0);
-  __lasx_xvst(b->chunks[1], reinterpret_cast<__m256i *>(output), 32);
+  __lsx_vst(b->chunks[0], reinterpret_cast<__m128i *>(output), 0);
+  __lsx_vst(b->chunks[1], reinterpret_cast<__m128i *>(output), 16);
+  __lsx_vst(b->chunks[2], reinterpret_cast<__m128i *>(output), 32);
+  __lsx_vst(b->chunks[3], reinterpret_cast<__m128i *>(output), 48);
 }
 
 static inline uint64_t compress_block(block64 *b, uint64_t mask, char *output) {
@@ -20245,80 +20249,152 @@ static inline uint64_t compress_block(block64 *b, uint64_t mask, char *output) {
   uint64_t count =
       __lsx_vpickve2gr_d(__lsx_vpcnt_h(__lsx_vreplgr2vr_d(nmask)), 0);
   uint16_t *count_ptr = (uint16_t *)&count;
-  compress(lasx_extracti128_lo(b->chunks[0]), uint16_t(mask), output);
-  compress(lasx_extracti128_hi(b->chunks[0]), uint16_t(mask >> 16),
-           output + count_ptr[0]);
-  compress(lasx_extracti128_lo(b->chunks[1]), uint16_t(mask >> 32),
+  compress(b->chunks[0], uint16_t(mask), output);
+  compress(b->chunks[1], uint16_t(mask >> 16), output + count_ptr[0]);
+  compress(b->chunks[2], uint16_t(mask >> 32),
            output + count_ptr[0] + count_ptr[1]);
-  compress(lasx_extracti128_hi(b->chunks[1]), uint16_t(mask >> 48),
+  compress(b->chunks[3], uint16_t(mask >> 48),
            output + count_ptr[0] + count_ptr[1] + count_ptr[2]);
   return count_ones(nmask);
 }
 
+template <typename T> bool is_power_of_two(T x) { return (x & (x - 1)) == 0; }
+
+inline size_t compress_block_single(block64 *b, uint64_t mask, char *output) {
+  const size_t pos64 = trailing_zeroes(mask);
+  const int8_t pos = pos64 & 0xf;
+  // Predefine the index vector
+  const v16u8 v1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+
+  switch (pos64 >> 4) {
+  case 0b00: {
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1); // v1 > v0
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(b->chunks[0], b->chunks[0], sh);
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 0 * 16), 0);
+    __lsx_vst(b->chunks[1], reinterpret_cast<__m128i *>(output + 1 * 16 - 1),
+              0);
+    __lsx_vst(b->chunks[2], reinterpret_cast<__m128i *>(output + 2 * 16 - 1),
+              0);
+    __lsx_vst(b->chunks[3], reinterpret_cast<__m128i *>(output + 3 * 16 - 1),
+              0);
+  } break;
+
+  case 0b01: {
+    __lsx_vst(b->chunks[0], reinterpret_cast<__m128i *>(output + 0 * 16), 0);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1);
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(b->chunks[1], b->chunks[1], sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 1 * 16), 0);
+    __lsx_vst(b->chunks[2], reinterpret_cast<__m128i *>(output + 2 * 16 - 1),
+              0);
+    __lsx_vst(b->chunks[3], reinterpret_cast<__m128i *>(output + 3 * 16 - 1),
+              0);
+  } break;
+
+  case 0b10: {
+    __lsx_vst(b->chunks[0], reinterpret_cast<__m128i *>(output + 0 * 16), 0);
+    __lsx_vst(b->chunks[1], reinterpret_cast<__m128i *>(output + 1 * 16), 0);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1);
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(b->chunks[2], b->chunks[2], sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 2 * 16), 0);
+    __lsx_vst(b->chunks[3], reinterpret_cast<__m128i *>(output + 3 * 16 - 1),
+              0);
+  } break;
+
+  case 0b11: {
+    __lsx_vst(b->chunks[0], reinterpret_cast<__m128i *>(output + 0 * 16), 0);
+    __lsx_vst(b->chunks[1], reinterpret_cast<__m128i *>(output + 1 * 16), 0);
+    __lsx_vst(b->chunks[2], reinterpret_cast<__m128i *>(output + 2 * 16), 0);
+
+    const __m128i v0 = __lsx_vreplgr2vr_b((uint8_t)(pos - 1));
+    const __m128i v2 = __lsx_vslt_b(v0, (__m128i)v1);
+    const __m128i sh = __lsx_vsub_b((__m128i)v1, v2);
+    const __m128i compressed = __lsx_vshuf_b(b->chunks[3], b->chunks[3], sh);
+
+    __lsx_vst(compressed, reinterpret_cast<__m128i *>(output + 3 * 16), 0);
+  } break;
+  }
+  return 63;
+}
+
 // The caller of this function is responsible to ensure that there are 64 bytes
 // available from reading at src. The data is read into a block64 structure.
 static inline void load_block(block64 *b, const char *src) {
-  b->chunks[0] = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0);
-  b->chunks[1] = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32);
+  b->chunks[0] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 0);
+  b->chunks[1] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 16);
+  b->chunks[2] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 32);
+  b->chunks[3] = __lsx_vld(reinterpret_cast<const __m128i *>(src), 48);
 }
 
 // The caller of this function is responsible to ensure that there are 128 bytes
 // available from reading at src. The data is read into a block64 structure.
 static inline void load_block(block64 *b, const char16_t *src) {
-  __m256i m1 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0);
-  __m256i m2 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32);
-  __m256i m3 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 64);
-  __m256i m4 = __lasx_xvld(reinterpret_cast<const __m256i *>(src), 96);
-  b->chunks[0] = __lasx_xvpermi_d(__lasx_xvssrlni_bu_h(m2, m1, 0), 0b11011000);
-  b->chunks[1] = __lasx_xvpermi_d(__lasx_xvssrlni_bu_h(m4, m3, 0), 0b11011000);
+  __m128i m1 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 0);
+  __m128i m2 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 16);
+  __m128i m3 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 32);
+  __m128i m4 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 48);
+  __m128i m5 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 64);
+  __m128i m6 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 80);
+  __m128i m7 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 96);
+  __m128i m8 = __lsx_vld(reinterpret_cast<const __m128i *>(src), 112);
+  b->chunks[0] = __lsx_vssrlni_bu_h(m2, m1, 0);
+  b->chunks[1] = __lsx_vssrlni_bu_h(m4, m3, 0);
+  b->chunks[2] = __lsx_vssrlni_bu_h(m6, m5, 0);
+  b->chunks[3] = __lsx_vssrlni_bu_h(m8, m7, 0);
 }
 
-static inline void base64_decode(char *out, __m256i str) {
-  __m256i t0 = __lasx_xvor_v(
-      __lasx_xvslli_w(str, 26),
-      __lasx_xvslli_w(__lasx_xvand_v(str, lasx_splat_u32(0x0000ff00)), 12));
-  __m256i t1 =
-      __lasx_xvsrli_w(__lasx_xvand_v(str, lasx_splat_u32(0x003f0000)), 2);
-  __m256i t2 = __lasx_xvor_v(t0, t1);
-  __m256i t3 = __lasx_xvor_v(t2, __lasx_xvsrli_w(str, 16));
-  __m256i pack_shuffle = ____m256i(
-      (__m128i)v16u8{3, 2, 1, 7, 6, 5, 11, 10, 9, 15, 14, 13, 0, 0, 0, 0});
-  t3 = __lasx_xvshuf_b(t3, t3, (__m256i)pack_shuffle);
+static inline void base64_decode(char *out, __m128i str) {
+  __m128i t0 = __lsx_vor_v(
+      __lsx_vslli_w(str, 26),
+      __lsx_vslli_w(__lsx_vand_v(str, lsx_splat_u32(0x0000FF00)), 12));
+  __m128i t1 = __lsx_vsrli_w(__lsx_vand_v(str, lsx_splat_u32(0x003F0000)), 2);
+  __m128i t2 = __lsx_vor_v(t0, t1);
+  __m128i t3 = __lsx_vor_v(t2, __lsx_vsrli_w(str, 16));
+  const v16u8 pack_shuffle = {3, 2,  1,  7,  6, 5, 11, 10,
+                              9, 15, 14, 13, 0, 0, 0,  0};
+  t3 = __lsx_vshuf_b(t3, t3, (__m128i)pack_shuffle);
 
   // Store the output:
-  __lsx_vst(lasx_extracti128_lo(t3), out, 0);
-  __lsx_vst(lasx_extracti128_hi(t3), out, 12);
+  // we only need 12.
+  __lsx_vstelm_d(t3, out, 0, 0);
+  __lsx_vstelm_w(t3, out + 8, 0, 2);
 }
 // decode 64 bytes and output 48 bytes
 static inline void base64_decode_block(char *out, const char *src) {
-  base64_decode(out, __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0));
+  base64_decode(out, __lsx_vld(reinterpret_cast<const __m128i *>(src), 0));
+  base64_decode(out + 12,
+                __lsx_vld(reinterpret_cast<const __m128i *>(src), 16));
   base64_decode(out + 24,
-                __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32));
+                __lsx_vld(reinterpret_cast<const __m128i *>(src), 32));
+  base64_decode(out + 36,
+                __lsx_vld(reinterpret_cast<const __m128i *>(src), 48));
 }
-
 static inline void base64_decode_block_safe(char *out, const char *src) {
-  base64_decode(out, __lasx_xvld(reinterpret_cast<const __m256i *>(src), 0));
-  char buffer[32];
-  base64_decode(buffer,
-                __lasx_xvld(reinterpret_cast<const __m256i *>(src), 32));
-  std::memcpy(out + 24, buffer, 24);
+  base64_decode_block(out, src);
 }
-
 static inline void base64_decode_block(char *out, block64 *b) {
   base64_decode(out, b->chunks[0]);
-  base64_decode(out + 24, b->chunks[1]);
+  base64_decode(out + 12, b->chunks[1]);
+  base64_decode(out + 24, b->chunks[2]);
+  base64_decode(out + 36, b->chunks[3]);
 }
 static inline void base64_decode_block_safe(char *out, block64 *b) {
-  base64_decode(out, b->chunks[0]);
-  char buffer[32];
-  base64_decode(buffer, b->chunks[1]);
-  std::memcpy(out + 24, buffer, 24);
+  base64_decode_block(out, b);
 }
 
 template <bool base64_url, bool ignore_garbage, bool default_or_url,
-          typename chartype>
+          typename char_type>
 full_result
-compress_decode_base64(char *dst, const chartype *src, size_t srclen,
+compress_decode_base64(char *dst, const char_type *src, size_t srclen,
                        base64_options options,
                        last_chunk_handling_options last_chunk_options) {
   const uint8_t *to_base64 =
@@ -20336,19 +20412,15 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
     }
     return {SUCCESS, full_input_length, 0};
   }
-  char *end_of_safe_64byte_zone =
-      (srclen + 3) / 4 * 3 >= 63 ? dst + (srclen + 3) / 4 * 3 - 63 : dst;
-
-  const chartype *const srcinit = src;
+  const char_type *const srcinit = src;
   const char *const dstinit = dst;
-  const chartype *const srcend = src + srclen;
+  const char_type *const srcend = src + srclen;
 
-  constexpr size_t block_size = 6;
-  static_assert(block_size >= 2, "block_size must be at least two");
+  constexpr size_t block_size = 10;
   char buffer[block_size * 64];
   char *bufferptr = buffer;
   if (srclen >= 64) {
-    const chartype *const srcend64 = src + srclen - 64;
+    const char_type *const srcend64 = src + srclen - 64;
     while (src <= srcend64) {
       block64 b;
       load_block(&b, src);
@@ -20356,55 +20428,49 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
       bool error = false;
       uint64_t badcharmask =
           to_base64_mask<base64_url, default_or_url>(&b, &error);
-      if (error && !ignore_garbage) {
-        src -= 64;
-        while (src < srcend && scalar::base64::is_eight_byte(*src) &&
-               to_base64[uint8_t(*src)] <= 64) {
-          src++;
+      if (badcharmask) {
+        if (error && !ignore_garbage) {
+          src -= 64;
+          while (src < srcend && scalar::base64::is_eight_byte(*src) &&
+                 to_base64[uint8_t(*src)] <= 64) {
+            src++;
+          }
+          if (src < srcend) {
+            // should never happen
+          }
+          return {error_code::INVALID_BASE64_CHARACTER, size_t(src - srcinit),
+                  size_t(dst - dstinit)};
         }
-        return {error_code::INVALID_BASE64_CHARACTER, size_t(src - srcinit),
-                size_t(dst - dstinit)};
       }
+
       if (badcharmask != 0) {
-        // optimization opportunity: check for simple masks like those made of
-        // continuous 1s followed by continuous 0s. And masks containing a
-        // single bad character.
-        bufferptr += compress_block(&b, badcharmask, bufferptr);
-      } else if (bufferptr != buffer) {
-        copy_block(&b, bufferptr);
-        bufferptr += 64;
-      } else {
-        if (dst >= end_of_safe_64byte_zone) {
-          base64_decode_block_safe(dst, &b);
+        if (is_power_of_two(badcharmask)) {
+          bufferptr += compress_block_single(&b, badcharmask, bufferptr);
         } else {
-          base64_decode_block(dst, &b);
+          bufferptr += compress_block(&b, badcharmask, bufferptr);
         }
-        dst += 48;
+      } else {
+        // optimization opportunity: if bufferptr == buffer and mask == 0, we
+        // can avoid the call to compress_block and decode directly.
+        copy_block(&b, bufferptr);
+        bufferptr += 64;
       }
       if (bufferptr >= (block_size - 1) * 64 + buffer) {
-        for (size_t i = 0; i < (block_size - 2); i++) {
+        for (size_t i = 0; i < (block_size - 1); i++) {
           base64_decode_block(dst, buffer + i * 64);
           dst += 48;
         }
-        if (dst >= end_of_safe_64byte_zone) {
-          base64_decode_block_safe(dst, buffer + (block_size - 2) * 64);
-        } else {
-          base64_decode_block(dst, buffer + (block_size - 2) * 64);
-        }
-        dst += 48;
         std::memcpy(buffer, buffer + (block_size - 1) * 64,
                     64); // 64 might be too much
         bufferptr -= (block_size - 1) * 64;
       }
     }
   }
-
   char *buffer_start = buffer;
   // Optimization note: if this is almost full, then it is worth our
   // time, otherwise, we should just decode directly.
   int last_block = (int)((bufferptr - buffer_start) % 64);
   if (last_block != 0 && srcend - src + last_block >= 64) {
-
     while ((bufferptr - buffer_start) % 64 != 0 && src < srcend) {
       uint8_t val = to_base64[uint8_t(*src)];
       *bufferptr = char(val);
@@ -20419,11 +20485,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   }
 
   for (; buffer_start + 64 <= bufferptr; buffer_start += 64) {
-    if (dst >= end_of_safe_64byte_zone) {
-      base64_decode_block_safe(dst, buffer_start);
-    } else {
-      base64_decode_block(dst, buffer_start);
-    }
+    base64_decode_block(dst, buffer_start);
     dst += 48;
   }
   if ((bufferptr - buffer_start) % 64 != 0) {
@@ -20433,6 +20495,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
                          (uint32_t(uint8_t(buffer_start[2])) << 1 * 6) +
                          (uint32_t(uint8_t(buffer_start[3])) << 0 * 6))
                         << 8;
+      // lsx is little-endian
       triple = scalar::u32_swap_bytes(triple);
       std::memcpy(dst, &triple, 4);
 
@@ -20445,6 +20508,7 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
                          (uint32_t(uint8_t(buffer_start[2])) << 1 * 6) +
                          (uint32_t(uint8_t(buffer_start[3])) << 0 * 6))
                         << 8;
+      // lsx is little-endian
       triple = scalar::u32_swap_bytes(triple);
       std::memcpy(dst, &triple, 3);
 
@@ -20504,24 +20568,22 @@ compress_decode_base64(char *dst, const chartype *src, size_t srclen,
   }
   return {SUCCESS, srclen, size_t(dst - dstinit)};
 }
-/* end file src/lasx/lasx_base64.cpp */
-/* begin file src/lasx/lasx_find.cpp */
+/* end file src/lsx/lsx_base64.cpp */
+/* begin file src/lsx/lsx_find.cpp */
 simdutf_really_inline const char *util_find(const char *start, const char *end,
                                             char character) noexcept {
   if (start >= end)
     return end;
 
-  const int step = 32;
-  __m256i char_vec = __lasx_xvreplgr2vr_b(static_cast<uint16_t>(character));
+  const int step = 16;
+  __m128i char_vec = __lsx_vreplgr2vr_b(static_cast<uint8_t>(character));
 
   while (end - start >= step) {
-    __m256i data = __lasx_xvld(reinterpret_cast<const __m256i *>(start), 0);
-    __m256i cmp = __lasx_xvseq_b(data, char_vec);
-    if (__lasx_xbnz_v(cmp)) {
-      __m256i res = __lasx_xvmsknz_b(cmp);
-      uint32_t mask0 = __lasx_xvpickve2gr_wu(res, 0);
-      uint32_t mask1 = __lasx_xvpickve2gr_wu(res, 4);
-      uint32_t mask = (mask0 | (mask1 << 16));
+    __m128i data = __lsx_vld(reinterpret_cast<const __m128i *>(start), 0);
+    __m128i cmp = __lsx_vseq_b(data, char_vec);
+    if (__lsx_bnz_v(cmp)) {
+      uint16_t mask =
+          static_cast<uint16_t>(__lsx_vpickve2gr_hu(__lsx_vmsknz_b(cmp), 0));
       return start + trailing_zeroes(mask);
     }
 
@@ -20544,17 +20606,15 @@ simdutf_really_inline const char16_t *util_find(const char16_t *start,
   if (start >= end)
     return end;
 
-  const int step = 16;
-  __m256i char_vec = __lasx_xvreplgr2vr_h(static_cast<uint16_t>(character));
+  const int step = 8;
+  __m128i char_vec = __lsx_vreplgr2vr_h(static_cast<uint16_t>(character));
 
   while (end - start >= step) {
-    __m256i data = __lasx_xvld(reinterpret_cast<const __m256i *>(start), 0);
-    __m256i cmp = __lasx_xvseq_h(data, char_vec);
-    if (__lasx_xbnz_v(cmp)) {
-      __m256i res = __lasx_xvmsknz_b(cmp);
-      uint32_t mask0 = __lasx_xvpickve2gr_wu(res, 0);
-      uint32_t mask1 = __lasx_xvpickve2gr_wu(res, 4);
-      uint32_t mask = (mask0 | (mask1 << 16));
+    __m128i data = __lsx_vld(reinterpret_cast<const __m128i *>(start), 0);
+    __m128i cmp = __lsx_vseq_h(data, char_vec);
+    if (__lsx_bnz_v(cmp)) {
+      uint16_t mask =
+          static_cast<uint16_t>(__lsx_vpickve2gr_hu(__lsx_vmsknz_b(cmp), 0));
       return start + trailing_zeroes(mask) / 2;
     }
 
@@ -20570,15 +20630,15 @@ simdutf_really_inline const char16_t *util_find(const char16_t *start,
 
   return end;
 }
-/* end file src/lasx/lasx_find.cpp */
+/* end file src/lsx/lsx_find.cpp */
 
 } // namespace
-} // namespace lasx
+} // namespace lsx
 } // namespace simdutf
 
 /* begin file src/generic/buf_block_reader.h */
 namespace simdutf {
-namespace lasx {
+namespace lsx {
 namespace {
 
 // Walks through a buffer in block-sized increments, loading the last part with
@@ -20609,40 +20669,6 @@ template <size_t STEP_SIZE> struct buf_block_reader {
   size_t idx;
 };
 
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text_64(const uint8_t *text) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    buf[i] = int8_t(text[i]) < ' ' ? '_' : int8_t(text[i]);
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-// Routines to print masks and text for debugging bitmask operations
-simdutf_unused static char *format_input_text(const simd8x64<uint8_t> &in) {
-  static char *buf =
-      reinterpret_cast<char *>(malloc(sizeof(simd8x64<uint8_t>) + 1));
-  in.store(reinterpret_cast<uint8_t *>(buf));
-  for (size_t i = 0; i < sizeof(simd8x64<uint8_t>); i++) {
-    if (buf[i] < ' ') {
-      buf[i] = '_';
-    }
-  }
-  buf[sizeof(simd8x64<uint8_t>)] = '\0';
-  return buf;
-}
-
-simdutf_unused static char *format_mask(uint64_t mask) {
-  static char *buf = reinterpret_cast<char *>(malloc(64 + 1));
-  for (size_t i = 0; i < 64; i++) {
-    buf[i] = (mask & (size_t(1) << i)) ? 'X' : ' ';
-  }
-  buf[64] = '\0';
-  return buf;
-}
-
 template <size_t STEP_SIZE>
 simdutf_really_inline
 buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len)
@@ -20684,15 +20710,81 @@ simdutf_really_inline void buf_block_reader<STEP_SIZE>::advance() {
 }
 
 } // unnamed namespace
-} // namespace lasx
+} // namespace lsx
 } // namespace simdutf
 /* end file src/generic/buf_block_reader.h */
 
+/* begin file src/generic/base64lengths.h */
+namespace simdutf {
+namespace lsx {
+namespace {
+namespace base64_lengths {
+
+simdutf_warn_unused size_t binary_length_from_base64(const char *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 64 <= length; pos += 64) {
+    simd8x64<uint8_t> block(reinterpret_cast<const uint8_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+simdutf_warn_unused size_t binary_length_from_base64(const char16_t *input,
+                                                     size_t length) {
+  size_t pos = 0;
+  size_t count = 0;
+  for (; pos + 32 <= length; pos += 32) {
+    simd16x32<uint16_t> block(reinterpret_cast<const uint16_t *>(input + pos));
+    uint64_t maybe_base64 = block.gteq(33); // >= 33 which is '!' in ASCII
+    count += count_ones(maybe_base64);
+  }
+  while (pos < length) {
+    count += (input[pos] > 0x20) ? 1 : 0;
+    pos++;
+  }
+  // Count padding at the end.
+  size_t padding = 0;
+  pos = length;
+  while (pos > 0 && padding < 2) {
+    char16_t c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+} // namespace base64_lengths
+} // unnamed namespace
+} // namespace lsx
+} // namespace simdutf
+/* end file src/generic/base64lengths.h */
+
 //
 // Implementation-specific overrides
 //
 namespace simdutf {
-namespace lasx {
+namespace lsx {
 
 simdutf_warn_unused result implementation::base64_to_binary(
     const char *input, size_t length, char *output, base64_options options,
@@ -20824,6 +20916,13 @@ size_t implementation::binary_to_base64(const char *input, size_t length,
   }
 }
 
+size_t implementation::binary_to_base64_with_lines(
+    const char *input, size_t length, char *output, size_t line_length,
+    base64_options options) const noexcept {
+  return scalar::base64::tail_encode_base64_impl<true>(output, input, length,
+                                                       options, line_length);
+}
+
 const char *implementation::find(const char *start, const char *end,
                                  char character) const noexcept {
   return util_find(start, end, character);
@@ -20834,14 +20933,404 @@ const char16_t *implementation::find(const char16_t *start, const char16_t *end,
   return util_find(start, end, character);
 }
 
-} // namespace lasx
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
+simdutf_warn_unused size_t implementation::binary_length_from_base64(
+    const char16_t *input, size_t length) const noexcept {
+  return base64_lengths::binary_length_from_base64(input, length);
+}
+
+} // namespace lsx
 } // namespace simdutf
 
-/* begin file src/simdutf/lasx/end.h */
+/* begin file src/simdutf/lsx/end.h */
 #undef SIMDUTF_SIMD_HAS_UNSIGNED_CMP
-/* end file src/simdutf/lasx/end.h */
-/* end file src/lasx/implementation.cpp */
+/* end file src/simdutf/lsx/end.h */
+/* end file src/lsx/implementation.cpp */
+#endif
+
+/* begin file src/simdutf_c.cpp */
+/* begin file include/simdutf_c.h */
+/***
+ * simdutf_c.h.h - C API for simdutf
+ * This is currently experimental.
+ * We are committed to keeping the C API, but there might be mistakes in our
+ * implementation. Please report any issues you find.
+ */
+
+#ifndef SIMDUTF_C_H
+#define SIMDUTF_C_H
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __has_include
+  #if __has_include(<uchar.h>)
+    #include <uchar.h>
+  #else // __has_include(<uchar.h>)
+    #define char16_t uint16_t
+    #define char32_t uint32_t
+  #endif // __has_include(<uchar.h>)
+#else    // __has_include(<uchar.h>)
+  #define char16_t uint16_t
+  #define char32_t uint32_t
+#endif // __has_include
+
+#ifdef __cplusplus
+extern "C" {
 #endif
 
+/* C-friendly subset of simdutf errors */
+typedef enum simdutf_error_code {
+  SIMDUTF_ERROR_SUCCESS = 0,
+  SIMDUTF_ERROR_HEADER_BITS,
+  SIMDUTF_ERROR_TOO_SHORT,
+  SIMDUTF_ERROR_TOO_LONG,
+  SIMDUTF_ERROR_OVERLONG,
+  SIMDUTF_ERROR_TOO_LARGE,
+  SIMDUTF_ERROR_SURROGATE,
+  SIMDUTF_ERROR_INVALID_BASE64_CHARACTER,
+  SIMDUTF_ERROR_BASE64_INPUT_REMAINDER,
+  SIMDUTF_ERROR_BASE64_EXTRA_BITS,
+  SIMDUTF_ERROR_OUTPUT_BUFFER_TOO_SMALL,
+  SIMDUTF_ERROR_OTHER
+} simdutf_error_code;
+
+typedef struct simdutf_result {
+  simdutf_error_code error;
+  size_t count; /* position of error or number of code units validated */
+} simdutf_result;
+
+typedef struct simdutf_full_result {
+  simdutf_error_code error;
+  size_t input_count;  /* number of input units consumed */
+  size_t output_count; /* number of output bytes written */
+} simdutf_full_result;
+
+typedef enum simdutf_encoding_type {
+  SIMDUTF_ENCODING_UNSPECIFIED = 0,
+  SIMDUTF_ENCODING_UTF8 = 1,
+  SIMDUTF_ENCODING_UTF16_LE = 2,
+  SIMDUTF_ENCODING_UTF16_BE = 4,
+  SIMDUTF_ENCODING_UTF32_LE = 8,
+  SIMDUTF_ENCODING_UTF32_BE = 16
+} simdutf_encoding_type;
+
+/* Validate UTF-8: returns true iff input is valid UTF-8 */
+bool simdutf_validate_utf8(const char *buf, size_t len);
+
+/* Validate UTF-8 with detailed result */
+simdutf_result simdutf_validate_utf8_with_errors(const char *buf, size_t len);
+
+/* Encoding detection */
+simdutf_encoding_type simdutf_autodetect_encoding(const char *input,
+                                                  size_t length);
+int simdutf_detect_encodings(const char *input, size_t length);
+
+/* ASCII validation */
+bool simdutf_validate_ascii(const char *buf, size_t len);
+simdutf_result simdutf_validate_ascii_with_errors(const char *buf, size_t len);
+
+/* UTF-16 ASCII checks */
+bool simdutf_validate_utf16_as_ascii(const char16_t *buf, size_t len);
+bool simdutf_validate_utf16be_as_ascii(const char16_t *buf, size_t len);
+bool simdutf_validate_utf16le_as_ascii(const char16_t *buf, size_t len);
+
+/* UTF-16/UTF-8/UTF-32 validation (native/endian-specific) */
+bool simdutf_validate_utf16(const char16_t *buf, size_t len);
+bool simdutf_validate_utf16le(const char16_t *buf, size_t len);
+bool simdutf_validate_utf16be(const char16_t *buf, size_t len);
+simdutf_result simdutf_validate_utf16_with_errors(const char16_t *buf,
+                                                  size_t len);
+simdutf_result simdutf_validate_utf16le_with_errors(const char16_t *buf,
+                                                    size_t len);
+simdutf_result simdutf_validate_utf16be_with_errors(const char16_t *buf,
+                                                    size_t len);
+
+bool simdutf_validate_utf32(const char32_t *buf, size_t len);
+simdutf_result simdutf_validate_utf32_with_errors(const char32_t *buf,
+                                                  size_t len);
+
+/* to_well_formed UTF-16 helpers */
+void simdutf_to_well_formed_utf16le(const char16_t *input, size_t len,
+                                    char16_t *output);
+void simdutf_to_well_formed_utf16be(const char16_t *input, size_t len,
+                                    char16_t *output);
+void simdutf_to_well_formed_utf16(const char16_t *input, size_t len,
+                                  char16_t *output);
+
+/* Counting */
+size_t simdutf_count_utf16(const char16_t *input, size_t length);
+size_t simdutf_count_utf16le(const char16_t *input, size_t length);
+size_t simdutf_count_utf16be(const char16_t *input, size_t length);
+size_t simdutf_count_utf8(const char *input, size_t length);
+
+/* Length estimators */
+size_t simdutf_utf8_length_from_latin1(const char *input, size_t length);
+size_t simdutf_latin1_length_from_utf8(const char *input, size_t length);
+size_t simdutf_latin1_length_from_utf16(size_t length);
+size_t simdutf_latin1_length_from_utf32(size_t length);
+size_t simdutf_utf16_length_from_utf8(const char *input, size_t length);
+size_t simdutf_utf32_length_from_utf8(const char *input, size_t length);
+size_t simdutf_utf8_length_from_utf16(const char16_t *input, size_t length);
+size_t simdutf_utf8_length_from_utf32(const char32_t *input, size_t length);
+simdutf_result
+simdutf_utf8_length_from_utf16_with_replacement(const char16_t *input,
+                                                size_t length);
+size_t simdutf_utf8_length_from_utf16le(const char16_t *input, size_t length);
+size_t simdutf_utf8_length_from_utf16be(const char16_t *input, size_t length);
+simdutf_result
+simdutf_utf8_length_from_utf16le_with_replacement(const char16_t *input,
+                                                  size_t length);
+simdutf_result
+simdutf_utf8_length_from_utf16be_with_replacement(const char16_t *input,
+                                                  size_t length);
+
+/* Conversions: latin1 <-> utf8, utf8 <-> utf16/utf32, utf16 <-> utf8, etc. */
+size_t simdutf_convert_latin1_to_utf8(const char *input, size_t length,
+                                      char *output);
+size_t simdutf_convert_latin1_to_utf8_safe(const char *input, size_t length,
+                                           char *output, size_t utf8_len);
+size_t simdutf_convert_latin1_to_utf16le(const char *input, size_t length,
+                                         char16_t *output);
+size_t simdutf_convert_latin1_to_utf16be(const char *input, size_t length,
+                                         char16_t *output);
+size_t simdutf_convert_latin1_to_utf16(const char *input, size_t length,
+                                       char16_t *output);
+size_t simdutf_convert_latin1_to_utf32(const char *input, size_t length,
+                                       char32_t *output);
+
+size_t simdutf_convert_utf8_to_latin1(const char *input, size_t length,
+                                      char *output);
+size_t simdutf_convert_utf8_to_utf16le(const char *input, size_t length,
+                                       char16_t *output);
+size_t simdutf_convert_utf8_to_utf16be(const char *input, size_t length,
+                                       char16_t *output);
+size_t simdutf_convert_utf8_to_utf16(const char *input, size_t length,
+                                     char16_t *output);
+
+size_t simdutf_convert_utf8_to_utf32(const char *input, size_t length,
+                                     char32_t *output);
+simdutf_result simdutf_convert_utf8_to_latin1_with_errors(const char *input,
+                                                          size_t length,
+                                                          char *output);
+simdutf_result simdutf_convert_utf8_to_utf16_with_errors(const char *input,
+                                                         size_t length,
+                                                         char16_t *output);
+simdutf_result simdutf_convert_utf8_to_utf16le_with_errors(const char *input,
+                                                           size_t length,
+                                                           char16_t *output);
+simdutf_result simdutf_convert_utf8_to_utf16be_with_errors(const char *input,
+                                                           size_t length,
+                                                           char16_t *output);
+simdutf_result simdutf_convert_utf8_to_utf32_with_errors(const char *input,
+                                                         size_t length,
+                                                         char32_t *output);
+
+/* Conversions assuming valid input */
+size_t simdutf_convert_valid_utf8_to_latin1(const char *input, size_t length,
+                                            char *output);
+size_t simdutf_convert_valid_utf8_to_utf16le(const char *input, size_t length,
+                                             char16_t *output);
+size_t simdutf_convert_valid_utf8_to_utf16be(const char *input, size_t length,
+                                             char16_t *output);
+size_t simdutf_convert_valid_utf8_to_utf32(const char *input, size_t length,
+                                           char32_t *output);
+
+/* UTF-16 -> UTF-8 and related conversions */
+size_t simdutf_convert_utf16_to_utf8(const char16_t *input, size_t length,
+                                     char *output);
+size_t simdutf_convert_utf16le_to_utf8(const char16_t *input, size_t length,
+                                       char *output);
+size_t simdutf_convert_utf16be_to_utf8(const char16_t *input, size_t length,
+                                       char *output);
+size_t simdutf_convert_utf16_to_utf8_safe(const char16_t *input, size_t length,
+                                          char *output, size_t utf8_len);
+size_t simdutf_convert_utf16_to_latin1(const char16_t *input, size_t length,
+                                       char *output);
+size_t simdutf_convert_utf16le_to_latin1(const char16_t *input, size_t length,
+                                         char *output);
+size_t simdutf_convert_utf16be_to_latin1(const char16_t *input, size_t length,
+                                         char *output);
+simdutf_result
+simdutf_convert_utf16_to_latin1_with_errors(const char16_t *input,
+                                            size_t length, char *output);
+simdutf_result
+simdutf_convert_utf16le_to_latin1_with_errors(const char16_t *input,
+                                              size_t length, char *output);
+simdutf_result
+simdutf_convert_utf16be_to_latin1_with_errors(const char16_t *input,
+                                              size_t length, char *output);
+
+simdutf_result simdutf_convert_utf16_to_utf8_with_errors(const char16_t *input,
+                                                         size_t length,
+                                                         char *output);
+simdutf_result
+simdutf_convert_utf16le_to_utf8_with_errors(const char16_t *input,
+                                            size_t length, char *output);
+simdutf_result
+simdutf_convert_utf16be_to_utf8_with_errors(const char16_t *input,
+                                            size_t length, char *output);
+
+size_t simdutf_convert_valid_utf16_to_utf8(const char16_t *input, size_t length,
+                                           char *output);
+size_t simdutf_convert_valid_utf16_to_latin1(const char16_t *input,
+                                             size_t length, char *output);
+size_t simdutf_convert_valid_utf16le_to_latin1(const char16_t *input,
+                                               size_t length, char *output);
+size_t simdutf_convert_valid_utf16be_to_latin1(const char16_t *input,
+                                               size_t length, char *output);
+
+size_t simdutf_convert_valid_utf16le_to_utf8(const char16_t *input,
+                                             size_t length, char *output);
+size_t simdutf_convert_valid_utf16be_to_utf8(const char16_t *input,
+                                             size_t length, char *output);
+
+/* UTF-16 <-> UTF-32 conversions */
+size_t simdutf_convert_utf16_to_utf32(const char16_t *input, size_t length,
+                                      char32_t *output);
+size_t simdutf_convert_utf16le_to_utf32(const char16_t *input, size_t length,
+                                        char32_t *output);
+size_t simdutf_convert_utf16be_to_utf32(const char16_t *input, size_t length,
+                                        char32_t *output);
+simdutf_result simdutf_convert_utf16_to_utf32_with_errors(const char16_t *input,
+                                                          size_t length,
+                                                          char32_t *output);
+simdutf_result
+simdutf_convert_utf16le_to_utf32_with_errors(const char16_t *input,
+                                             size_t length, char32_t *output);
+simdutf_result
+simdutf_convert_utf16be_to_utf32_with_errors(const char16_t *input,
+                                             size_t length, char32_t *output);
+
+/* Valid UTF-16 conversions */
+size_t simdutf_convert_valid_utf16_to_utf32(const char16_t *input,
+                                            size_t length, char32_t *output);
+size_t simdutf_convert_valid_utf16le_to_utf32(const char16_t *input,
+                                              size_t length, char32_t *output);
+size_t simdutf_convert_valid_utf16be_to_utf32(const char16_t *input,
+                                              size_t length, char32_t *output);
+
+/* UTF-32 -> ... conversions */
+size_t simdutf_convert_utf32_to_utf8(const char32_t *input, size_t length,
+                                     char *output);
+simdutf_result simdutf_convert_utf32_to_utf8_with_errors(const char32_t *input,
+                                                         size_t length,
+                                                         char *output);
+size_t simdutf_convert_valid_utf32_to_utf8(const char32_t *input, size_t length,
+                                           char *output);
+
+size_t simdutf_convert_utf32_to_utf16(const char32_t *input, size_t length,
+                                      char16_t *output);
+size_t simdutf_convert_utf32_to_utf16le(const char32_t *input, size_t length,
+                                        char16_t *output);
+size_t simdutf_convert_utf32_to_utf16be(const char32_t *input, size_t length,
+                                        char16_t *output);
+simdutf_result
+simdutf_convert_utf32_to_latin1_with_errors(const char32_t *input,
+                                            size_t length, char *output);
+
+/* --- Find helpers --- */
+const char *simdutf_find(const char *start, const char *end, char character);
+const char16_t *simdutf_find_utf16(const char16_t *start, const char16_t *end,
+                                   char16_t character);
+
+/* --- Base64 enums and helpers --- */
+typedef enum simdutf_base64_options {
+  SIMDUTF_BASE64_DEFAULT = 0,
+  SIMDUTF_BASE64_URL = 1,
+  SIMDUTF_BASE64_DEFAULT_NO_PADDING = 2,
+  SIMDUTF_BASE64_URL_WITH_PADDING = 3,
+  SIMDUTF_BASE64_DEFAULT_ACCEPT_GARBAGE = 4,
+  SIMDUTF_BASE64_URL_ACCEPT_GARBAGE = 5,
+  SIMDUTF_BASE64_DEFAULT_OR_URL = 8,
+  SIMDUTF_BASE64_DEFAULT_OR_URL_ACCEPT_GARBAGE = 12
+} simdutf_base64_options;
+
+typedef enum simdutf_last_chunk_handling_options {
+  SIMDUTF_LAST_CHUNK_LOOSE = 0,
+  SIMDUTF_LAST_CHUNK_STRICT = 1,
+  SIMDUTF_LAST_CHUNK_STOP_BEFORE_PARTIAL = 2,
+  SIMDUTF_LAST_CHUNK_ONLY_FULL_CHUNKS = 3
+} simdutf_last_chunk_handling_options;
+
+/* maximal binary length estimators */
+size_t simdutf_maximal_binary_length_from_base64(const char *input,
+                                                 size_t length);
+size_t simdutf_maximal_binary_length_from_base64_utf16(const char16_t *input,
+                                                       size_t length);
+
+/* base64 decoding/encoding */
+simdutf_result simdutf_base64_to_binary(
+    const char *input, size_t length, char *output,
+    simdutf_base64_options options,
+    simdutf_last_chunk_handling_options last_chunk_options);
+simdutf_result simdutf_base64_to_binary_utf16(
+    const char16_t *input, size_t length, char *output,
+    simdutf_base64_options options,
+    simdutf_last_chunk_handling_options last_chunk_options);
+
+size_t simdutf_base64_length_from_binary(size_t length,
+                                         simdutf_base64_options options);
+size_t simdutf_base64_length_from_binary_with_lines(
+    size_t length, simdutf_base64_options options, size_t line_length);
+
+size_t simdutf_binary_to_base64(const char *input, size_t length, char *output,
+                                simdutf_base64_options options);
+size_t simdutf_binary_to_base64_with_lines(const char *input, size_t length,
+                                           char *output, size_t line_length,
+                                           simdutf_base64_options options);
+
+/* safe decoding that provides an in/out outlen parameter */
+simdutf_result simdutf_base64_to_binary_safe(
+    const char *input, size_t length, char *output, size_t *outlen,
+    simdutf_base64_options options,
+    simdutf_last_chunk_handling_options last_chunk_options,
+    bool decode_up_to_bad_char);
+simdutf_result simdutf_base64_to_binary_safe_utf16(
+    const char16_t *input, size_t length, char *output, size_t *outlen,
+    simdutf_base64_options options,
+    simdutf_last_chunk_handling_options last_chunk_options,
+    bool decode_up_to_bad_char);
+
+/* detailed decoding returning input_count and output_count */
+simdutf_full_result simdutf_base64_to_binary_details(
+    const char *input, size_t length, char *output,
+    simdutf_base64_options options,
+    simdutf_last_chunk_handling_options last_chunk_options);
+simdutf_full_result simdutf_base64_to_binary_details_utf16(
+    const char16_t *input, size_t length, char *output,
+    simdutf_base64_options options,
+    simdutf_last_chunk_handling_options last_chunk_options);
+
+/* single-character base64 validation */
+bool simdutf_base64_valid(char input, simdutf_base64_options options);
+bool simdutf_base64_valid_utf16(char16_t input, simdutf_base64_options options);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* SIMDUTF_C_H */
+/* end file include/simdutf_c.h */
+
+static simdutf_result to_c_result(const simdutf::result &r) {
+  simdutf_result out;
+  out.error = static_cast<simdutf_error_code>(r.error);
+  out.count = r.count;
+  return out;
+}
+
+/* The C wrapper depends on the library features. Only expose the C API
+   when all relevant feature is enabled. This helps the
+   single-header generator to omit the C wrapper when features are
+   disabled. */
+// clang-format off
+// clang-format on
+/* end file src/simdutf_c.cpp */
 SIMDUTF_POP_DISABLE_WARNINGS
 /* end file src/simdutf.cpp */
diff --git a/cpp/simdutf.h b/cpp/simdutf.h
index 3f8d4f3..3900b0c 100644
--- a/cpp/simdutf.h
+++ b/cpp/simdutf.h
@@ -1,4 +1,4 @@
-/* auto-generated on 2025-09-10 16:01:38 -0400. Do not edit! */
+/* auto-generated on 2026-05-07 06:54:06 +0200. Do not edit! */
 /* begin file include/simdutf.h */
 #ifndef SIMDUTF_H
 #define SIMDUTF_H
@@ -20,6 +20,11 @@
   #endif
 #endif
 
+// C++ 26
+#if !defined(SIMDUTF_CPLUSPLUS26) && (SIMDUTF_CPLUSPLUS >= 202602L)
+  #define SIMDUTF_CPLUSPLUS26 1
+#endif
+
 // C++ 23
 #if !defined(SIMDUTF_CPLUSPLUS23) && (SIMDUTF_CPLUSPLUS >= 202302L)
   #define SIMDUTF_CPLUSPLUS23 1
@@ -45,8 +50,8 @@
   #define SIMDUTF_CPLUSPLUS11 1
 #endif
 
-#ifndef SIMDUTF_CPLUSPLUS11
-  #error simdutf requires a compiler compliant with the C++11 standard
+#ifndef SIMDUTF_CPLUSPLUS17
+  #error simdutf requires a compiler compliant with the C++17 standard
 #endif
 
 #endif // SIMDUTF_COMPILER_CHECK_H
@@ -63,6 +68,7 @@
 #include <cfloat>
 #include <cstddef>
 #include <cstdint>
+#include <cstdio>
 #include <cstdlib>
 #ifndef _WIN32
   // strcasecmp, strncasecmp
@@ -200,9 +206,25 @@
 #elif defined(__loongarch_lp64)
   #if defined(__loongarch_sx) && defined(__loongarch_asx)
     #define SIMDUTF_IS_LSX 1
-    #define SIMDUTF_IS_LASX 1
+    #define SIMDUTF_IS_LASX 1 // We can always run both
   #elif defined(__loongarch_sx)
     #define SIMDUTF_IS_LSX 1
+    // Adjust for runtime dispatching support.
+    #if defined(__GNUC__) && !defined(__clang__) &&                            \
+        !defined(__INTEL_COMPILER) && !defined(__NVCOMPILER)
+      #if __GNUC__ > 15 || (__GNUC__ == 15 && __GNUC_MINOR__ >= 0)
+        // We are ok, we will support runtime dispatch for LASX.
+      #else
+        // We disable runtime dispatch for LASX, which means that we will not be
+        // able to use LASX even if it is supported by the hardware. Loongson
+        // users should update to GCC 15 or better.
+        #define SIMDUTF_IMPLEMENTATION_LASX 0
+      #endif
+    #else
+      // We are not using GCC, so we assume that we can support runtime dispatch
+      // for LASX. https://godbolt.org/z/jcMnrjYhs
+      #define SIMDUTF_IMPLEMENTATION_LASX 0
+    #endif
   #endif
 #else
   // The simdutf library is designed
@@ -250,7 +272,7 @@
 //
 
 // We are going to use runtime dispatch.
-#ifdef SIMDUTF_IS_X86_64
+#if defined(SIMDUTF_IS_X86_64) || defined(SIMDUTF_IS_LSX)
   #ifdef __clang__
     // clang does not have GCC push pop
     // warning: clang attribute push can't be used within a namespace in clang
@@ -267,7 +289,7 @@
     #define SIMDUTF_UNTARGET_REGION _Pragma("GCC pop_options")
   #endif // clang then gcc
 
-#endif // x86
+#endif // defined(SIMDUTF_IS_X86_64) || defined(SIMDUTF_IS_LSX)
 
 // Default target region macros don't do anything.
 #ifndef SIMDUTF_TARGET_REGION
@@ -526,6 +548,14 @@
 
 #endif // MSC_VER
 
+// Will evaluate to constexpr in C++23 or later. This makes it possible to mark
+// functions constexpr if the "if consteval" feature is available to use.
+#if SIMDUTF_CPLUSPLUS23
+  #define simdutf_constexpr23 constexpr
+#else
+  #define simdutf_constexpr23
+#endif
+
 #ifndef SIMDUTF_DLLIMPORTEXPORT
   #if defined(SIMDUTF_VISUAL_STUDIO) // Visual Studio
                                      /**
@@ -576,7 +606,13 @@
 /* begin file include/simdutf/encoding_types.h */
 #ifndef SIMDUTF_ENCODING_TYPES_H
 #define SIMDUTF_ENCODING_TYPES_H
-#include <string>
+#include <string_view>
+
+#if !defined(SIMDUTF_NO_STD_TEXT_ENCODING) &&                                  \
+    defined(__cpp_lib_text_encoding) && __cpp_lib_text_encoding >= 202306L
+  #define SIMDUTF_HAS_STD_TEXT_ENCODING 1
+  #include <text_encoding>
+#endif
 
 namespace simdutf {
 
@@ -591,11 +627,27 @@ enum encoding_type {
   unspecified = 0
 };
 
-enum endianness { LITTLE = 0, BIG = 1 };
+#ifndef SIMDUTF_IS_BIG_ENDIAN
+  #error "SIMDUTF_IS_BIG_ENDIAN needs to be defined."
+#endif
+
+enum endianness {
+  LITTLE = 0,
+  BIG = 1,
+  NATIVE =
+#if SIMDUTF_IS_BIG_ENDIAN
+      BIG
+#else
+      LITTLE
+#endif
+};
 
-bool match_system(endianness e);
+simdutf_warn_unused simdutf_really_inline constexpr bool
+match_system(endianness e) {
+  return e == endianness::NATIVE;
+}
 
-std::string to_string(encoding_type bom);
+simdutf_warn_unused std::string_view to_string(encoding_type bom);
 
 // Note that BOM for UTF8 is discouraged.
 namespace BOM {
@@ -607,23 +659,144 @@ namespace BOM {
  * @return the corresponding encoding
  */
 
-encoding_type check_bom(const uint8_t *byte, size_t length);
-encoding_type check_bom(const char *byte, size_t length);
+simdutf_warn_unused encoding_type check_bom(const uint8_t *byte, size_t length);
+simdutf_warn_unused encoding_type check_bom(const char *byte, size_t length);
 /**
  * Returns the size, in bytes, of the BOM for a given encoding type.
  * Note that UTF8 BOM are discouraged.
  * @param bom         the encoding type
  * @return the size in bytes of the corresponding BOM
  */
-size_t bom_byte_size(encoding_type bom);
+simdutf_warn_unused size_t bom_byte_size(encoding_type bom);
 
 } // namespace BOM
+
+#ifdef SIMDUTF_HAS_STD_TEXT_ENCODING
+/**
+ * Convert a simdutf encoding type to a std::text_encoding.
+ *
+ * @param enc  the simdutf encoding type
+ * @return     the corresponding std::text_encoding, or
+ *             std::text_encoding::id::unknown for unspecified/unsupported
+ */
+simdutf_warn_unused constexpr std::text_encoding
+to_std_encoding(encoding_type enc) noexcept {
+  switch (enc) {
+  case UTF8:
+    return std::text_encoding(std::text_encoding::id::UTF8);
+  case UTF16_LE:
+    return std::text_encoding(std::text_encoding::id::UTF16LE);
+  case UTF16_BE:
+    return std::text_encoding(std::text_encoding::id::UTF16BE);
+  case UTF32_LE:
+    return std::text_encoding(std::text_encoding::id::UTF32LE);
+  case UTF32_BE:
+    return std::text_encoding(std::text_encoding::id::UTF32BE);
+  case Latin1:
+    return std::text_encoding(std::text_encoding::id::ISOLatin1);
+  case unspecified:
+  default:
+    return std::text_encoding(std::text_encoding::id::unknown);
+  }
+}
+
+/**
+ * Convert a std::text_encoding to a simdutf encoding type.
+ *
+ * @param enc  the std::text_encoding
+ * @return     the corresponding simdutf encoding type, or
+ *             encoding_type::unspecified if the encoding is not supported
+ */
+simdutf_warn_unused constexpr encoding_type
+from_std_encoding(const std::text_encoding &enc) noexcept {
+  switch (enc.mib()) {
+  case std::text_encoding::id::UTF8:
+    return UTF8;
+  case std::text_encoding::id::UTF16LE:
+    return UTF16_LE;
+  case std::text_encoding::id::UTF16BE:
+    return UTF16_BE;
+  case std::text_encoding::id::UTF32LE:
+    return UTF32_LE;
+  case std::text_encoding::id::UTF32BE:
+    return UTF32_BE;
+  case std::text_encoding::id::ISOLatin1:
+    return Latin1;
+  default:
+    return unspecified;
+  }
+}
+
+/**
+ * Get the native-endian UTF-16 encoding type for this system.
+ *
+ * @return UTF16_LE on little-endian systems, UTF16_BE on big-endian systems
+ */
+simdutf_warn_unused constexpr encoding_type native_utf16_encoding() noexcept {
+  #if SIMDUTF_IS_BIG_ENDIAN
+  return UTF16_BE;
+  #else
+  return UTF16_LE;
+  #endif
+}
+
+/**
+ * Get the native-endian UTF-32 encoding type for this system.
+ *
+ * @return UTF32_LE on little-endian systems, UTF32_BE on big-endian systems
+ */
+simdutf_warn_unused constexpr encoding_type native_utf32_encoding() noexcept {
+  #if SIMDUTF_IS_BIG_ENDIAN
+  return UTF32_BE;
+  #else
+  return UTF32_LE;
+  #endif
+}
+
+/**
+ * Convert a std::text_encoding to a simdutf encoding type,
+ * using native endianness for UTF-16/UTF-32 without explicit endianness.
+ *
+ * When the input is std::text_encoding::id::UTF16 or UTF32 (without LE/BE
+ * suffix), this returns the native-endian simdutf variant.
+ *
+ * @param enc  the std::text_encoding
+ * @return     the corresponding simdutf encoding type, or
+ *             encoding_type::unspecified if the encoding is not supported
+ */
+simdutf_warn_unused constexpr encoding_type
+from_std_encoding_native(const std::text_encoding &enc) noexcept {
+  switch (enc.mib()) {
+  case std::text_encoding::id::UTF8:
+    return UTF8;
+  case std::text_encoding::id::UTF16:
+    return native_utf16_encoding();
+  case std::text_encoding::id::UTF16LE:
+    return UTF16_LE;
+  case std::text_encoding::id::UTF16BE:
+    return UTF16_BE;
+  case std::text_encoding::id::UTF32:
+    return native_utf32_encoding();
+  case std::text_encoding::id::UTF32LE:
+    return UTF32_LE;
+  case std::text_encoding::id::UTF32BE:
+    return UTF32_BE;
+  case std::text_encoding::id::ISOLatin1:
+    return Latin1;
+  default:
+    return unspecified;
+  }
+}
+#endif // SIMDUTF_HAS_STD_TEXT_ENCODING
+
 } // namespace simdutf
 #endif
 /* end file include/simdutf/encoding_types.h */
 /* begin file include/simdutf/error.h */
 #ifndef SIMDUTF_ERROR_H
 #define SIMDUTF_ERROR_H
+#include <string_view>
+
 namespace simdutf {
 
 enum error_code {
@@ -641,9 +814,19 @@ enum error_code {
              // U+10FFFF,less than or equal than U+7F for ASCII OR less than
              // equal than U+FF for Latin1
   SURROGATE, // The decoded character must be not be in U+D800...DFFF (UTF-8 or
-             // UTF-32) OR a high surrogate must be followed by a low surrogate
+             // UTF-32)
+             // OR
+             // a high surrogate must be followed by a low surrogate
              // and a low surrogate must be preceded by a high surrogate
-             // (UTF-16) OR there must be no surrogate at all (Latin1)
+             // (UTF-16)
+             // OR
+             // there must be no surrogate at all and one is
+             // found (Latin1 functions)
+             // OR
+             // *specifically* for the function
+             // utf8_length_from_utf16_with_replacement, a surrogate (whether
+             // in error or not) has been found (I.e., whether we are in the
+             // Basic Multilingual Plane or not).
   INVALID_BASE64_CHARACTER, // Found a character that cannot be part of a valid
                             // base64 string. This may include a misplaced
                             // padding character ('=').
@@ -655,7 +838,7 @@ enum error_code {
   OUTPUT_BUFFER_TOO_SMALL,  // The provided buffer is too small.
   OTHER                     // Not related to validation/transcoding.
 };
-#if SIMDUTF_CPLUSPLUS17
+
 inline std::string_view error_to_string(error_code code) noexcept {
   switch (code) {
   case SUCCESS:
@@ -684,7 +867,6 @@ inline std::string_view error_to_string(error_code code) noexcept {
     return "OTHER";
   }
 }
-#endif
 
 struct result {
   error_code error;
@@ -692,17 +874,18 @@ struct result {
                 // case of success, indicates the number of code units
                 // validated/written.
 
-  simdutf_really_inline result() noexcept
+  simdutf_really_inline simdutf_constexpr23 result() noexcept
       : error{error_code::SUCCESS}, count{0} {}
 
-  simdutf_really_inline result(error_code err, size_t pos) noexcept
+  simdutf_really_inline simdutf_constexpr23 result(error_code err,
+                                                   size_t pos) noexcept
       : error{err}, count{pos} {}
 
-  simdutf_really_inline bool is_ok() const noexcept {
+  simdutf_really_inline simdutf_constexpr23 bool is_ok() const noexcept {
     return error == error_code::SUCCESS;
   }
 
-  simdutf_really_inline bool is_err() const noexcept {
+  simdutf_really_inline simdutf_constexpr23 bool is_err() const noexcept {
     return error != error_code::SUCCESS;
   }
 };
@@ -714,18 +897,19 @@ struct full_result {
   bool padding_error = false; // true if the error is due to padding, only
                               // meaningful when error is not SUCCESS
 
-  simdutf_really_inline full_result() noexcept
+  simdutf_really_inline simdutf_constexpr23 full_result() noexcept
       : error{error_code::SUCCESS}, input_count{0}, output_count{0} {}
 
-  simdutf_really_inline full_result(error_code err, size_t pos_in,
-                                    size_t pos_out) noexcept
+  simdutf_really_inline simdutf_constexpr23 full_result(error_code err,
+                                                        size_t pos_in,
+                                                        size_t pos_out) noexcept
       : error{err}, input_count{pos_in}, output_count{pos_out} {}
-  simdutf_really_inline full_result(error_code err, size_t pos_in,
-                                    size_t pos_out, bool padding_err) noexcept
+  simdutf_really_inline simdutf_constexpr23 full_result(
+      error_code err, size_t pos_in, size_t pos_out, bool padding_err) noexcept
       : error{err}, input_count{pos_in}, output_count{pos_out},
         padding_error{padding_err} {}
 
-  simdutf_really_inline operator result() const noexcept {
+  simdutf_really_inline simdutf_constexpr23 operator result() const noexcept {
     if (error == error_code::SUCCESS) {
       return result{error, output_count};
     } else {
@@ -749,18 +933,18 @@ SIMDUTF_DISABLE_UNDESIRED_WARNINGS
 #define SIMDUTF_SIMDUTF_VERSION_H
 
 /** The version of simdutf being used (major.minor.revision) */
-#define SIMDUTF_VERSION "7.4.0"
+#define SIMDUTF_VERSION "9.0.0"
 
 namespace simdutf {
 enum {
   /**
    * The major version (MAJOR.minor.revision) of simdutf being used.
    */
-  SIMDUTF_VERSION_MAJOR = 7,
+  SIMDUTF_VERSION_MAJOR = 9,
   /**
    * The minor version (major.MINOR.revision) of simdutf being used.
    */
-  SIMDUTF_VERSION_MINOR = 4,
+  SIMDUTF_VERSION_MINOR = 0,
   /**
    * The revision (major.minor.REVISION) of simdutf being used.
    */
@@ -776,7 +960,6 @@ enum {
 #if !defined(SIMDUTF_NO_THREADS)
   #include <atomic>
 #endif
-#include <string>
 #ifdef SIMDUTF_INTERNAL_TESTS
   #include <vector>
 #endif
@@ -1107,14 +1290,13 @@ static inline uint32_t detect_supported_architectures() {
 #endif // SIMDutf_INTERNAL_ISADETECTION_H
 /* end file include/simdutf/internal/isadetection.h */
 
+#include <string_view>
 #if SIMDUTF_SPAN
   #include <concepts>
   #include <type_traits>
   #include <span>
   #include <tuple>
-#endif
-#if SIMDUTF_CPLUSPLUS17
-  #include <string_view>
+  #include <utility> // for std::unreachable
 #endif
 // The following defines are conditionally enabled/disabled during amalgamation.
 // By default all features are enabled, regular code shouldn't check them. Only
@@ -1133,20 +1315,163 @@ static inline uint32_t detect_supported_architectures() {
 #define SIMDUTF_FEATURE_UTF32 0
 #define SIMDUTF_FEATURE_BASE64 1
 
+#if SIMDUTF_CPLUSPLUS23
+/* begin file include/simdutf/constexpr_ptr.h */
+#ifndef SIMDUTF_CONSTEXPR_PTR_H
+#define SIMDUTF_CONSTEXPR_PTR_H
+
+#include <cstddef>
+
 namespace simdutf {
+namespace detail {
+/**
+ * The constexpr_ptr class is a workaround for reinterpret_cast not being
+ * allowed during constant evaluation.
+ */
+template <typename to, typename from>
+  requires(sizeof(to) == sizeof(from))
+struct constexpr_ptr {
+  const from *p;
+
+  constexpr explicit constexpr_ptr(const from *ptr) noexcept : p(ptr) {}
+
+  constexpr to operator*() const noexcept { return static_cast<to>(*p); }
+
+  constexpr constexpr_ptr &operator++() noexcept {
+    ++p;
+    return *this;
+  }
+
+  constexpr constexpr_ptr operator++(int) noexcept {
+    auto old = *this;
+    ++p;
+    return old;
+  }
+
+  constexpr constexpr_ptr &operator--() noexcept {
+    --p;
+    return *this;
+  }
+
+  constexpr constexpr_ptr operator--(int) noexcept {
+    auto old = *this;
+    --p;
+    return old;
+  }
+
+  constexpr constexpr_ptr &operator+=(std::ptrdiff_t n) noexcept {
+    p += n;
+    return *this;
+  }
+
+  constexpr constexpr_ptr &operator-=(std::ptrdiff_t n) noexcept {
+    p -= n;
+    return *this;
+  }
+
+  constexpr constexpr_ptr operator+(std::ptrdiff_t n) const noexcept {
+    return constexpr_ptr{p + n};
+  }
+
+  constexpr constexpr_ptr operator-(std::ptrdiff_t n) const noexcept {
+    return constexpr_ptr{p - n};
+  }
+
+  constexpr std::ptrdiff_t operator-(const constexpr_ptr &o) const noexcept {
+    return p - o.p;
+  }
+
+  constexpr to operator[](std::ptrdiff_t n) const noexcept {
+    return static_cast<to>(*(p + n));
+  }
+
+  // to prevent compilation errors for memcpy, even if it is never
+  // called during constant evaluation
+  constexpr operator const void *() const noexcept { return p; }
+};
+
+template <typename to, typename from>
+constexpr constexpr_ptr<to, from> constexpr_cast_ptr(from *p) noexcept {
+  return constexpr_ptr<to, from>{p};
+}
+
+/**
+ * helper type for constexpr_writeptr, so it is possible to
+ * do "*ptr = val;"
+ */
+template <typename SrcType, typename TargetType>
+struct constexpr_write_ptr_proxy {
+
+  constexpr explicit constexpr_write_ptr_proxy(TargetType *raw) : p(raw) {}
+
+  constexpr constexpr_write_ptr_proxy &operator=(SrcType v) {
+    *p = static_cast<TargetType>(v);
+    return *this;
+  }
+
+  TargetType *p;
+};
+
+/**
+ * helper for working around reinterpret_cast not being allowed during constexpr
+ * evaluation. will try to act as a SrcType* but actually write to the pointer
+ * given in the constructor, which is of another type TargetType
+ */
+template <typename SrcType, typename TargetType> struct constexpr_write_ptr {
+  constexpr explicit constexpr_write_ptr(TargetType *raw) : p(raw) {}
+
+  constexpr constexpr_write_ptr_proxy<SrcType, TargetType> operator*() const {
+    return constexpr_write_ptr_proxy<SrcType, TargetType>{p};
+  }
+
+  constexpr constexpr_write_ptr_proxy<SrcType, TargetType>
+  operator[](std::ptrdiff_t n) const {
+    return constexpr_write_ptr_proxy<SrcType, TargetType>{p + n};
+  }
+
+  constexpr constexpr_write_ptr &operator++() {
+    ++p;
+    return *this;
+  }
+
+  constexpr constexpr_write_ptr operator++(int) {
+    constexpr_write_ptr old = *this;
+    ++p;
+    return old;
+  }
+
+  constexpr std::ptrdiff_t operator-(const constexpr_write_ptr &other) const {
+    return p - other.p;
+  }
+
+  TargetType *p;
+};
+
+template <typename SrcType, typename TargetType>
+constexpr auto constexpr_cast_writeptr(TargetType *raw) {
+  return constexpr_write_ptr<SrcType, TargetType>{raw};
+}
+
+} // namespace detail
+} // namespace simdutf
+#endif
+/* end file include/simdutf/constexpr_ptr.h */
+#endif
 
 #if SIMDUTF_SPAN
 /// helpers placed in namespace detail are not a part of the public API
+namespace simdutf {
 namespace detail {
 /**
  * matches a byte, in the many ways C++ allows. note that these
  * are all distinct types.
  */
 template <typename T>
-concept byte_like = std::is_same_v<T, std::byte> ||   //
-                    std::is_same_v<T, char> ||        //
-                    std::is_same_v<T, signed char> || //
-                    std::is_same_v<T, unsigned char>;
+concept byte_like = std::is_same_v<T, std::byte> ||     //
+                    std::is_same_v<T, char> ||          //
+                    std::is_same_v<T, signed char> ||   //
+                    std::is_same_v<T, unsigned char> || //
+                    std::is_same_v<T, char8_t>;
 
 template <typename T>
 concept is_byte_like = byte_like<std::remove_cvref_t<T>>;
@@ -1179,165 +1504,5619 @@ concept output_span_of_byte_like = requires(T &t) {
   { *t.data() } noexcept -> is_byte_like;
   { *t.data() } noexcept -> is_mutable;
 };
-} // namespace detail
-#endif
 
 /**
- * Validate the ASCII string as a UTF-16LE sequence.
- * An UTF-16 sequence is considered an ASCII sequence
- * if it could be converted to an ASCII string losslessly.
- *
- * Overridden by each implementation.
- *
- * @param buf the UTF-16LE string to validate.
- * @param len the length of the string in bytes.
- * @return true if and only if the string is valid ASCII.
+ * a pointer like object, when indexed, results in a byte like result.
+ * valid examples: char*, const char*, std::array<char,10>
+ * invalid examples: int*, std::array<int,10>
  */
-simdutf_warn_unused bool validate_utf16le_as_ascii(const char16_t *buf,
-                                                   size_t len) noexcept;
-#if SIMDUTF_SPAN
-simdutf_really_inline simdutf_warn_unused bool
-validate_utf16le_as_ascii(std::span<const char16_t> input) noexcept {
-  return validate_utf16le_as_ascii(input.data(), input.size());
-}
-#endif // SIMDUTF_SPAN
-
-  #ifndef SIMDUTF_NEED_TRAILING_ZEROES
-    #define SIMDUTF_NEED_TRAILING_ZEROES 1
-  #endif
-// base64_options are used to specify the base64 encoding options.
-// ASCII spaces are ' ', '\t', '\n', '\r', '\f'
-// garbage characters are characters that are not part of the base64 alphabet
-// nor ASCII spaces.
-constexpr uint64_t base64_reverse_padding =
-    2; /* modifier for base64_default and base64_url */
-enum base64_options : uint64_t {
-  base64_default = 0, /* standard base64 format (with padding) */
-  base64_url = 1,     /* base64url format (no padding) */
-  base64_default_no_padding =
-      base64_default |
-      base64_reverse_padding, /* standard base64 format without padding */
-  base64_url_with_padding =
-      base64_url | base64_reverse_padding, /* base64url with padding */
-  base64_default_accept_garbage =
-      4, /* standard base64 format accepting garbage characters, the input stops
-            with the first '=' if any */
-  base64_url_accept_garbage =
-      5, /* base64url format accepting garbage characters, the input stops with
-            the first '=' if any */
-  base64_default_or_url =
-      8, /* standard/base64url hybrid format (only meaningful for decoding!) */
-  base64_default_or_url_accept_garbage =
-      12, /* standard/base64url hybrid format accepting garbage characters
-             (only meaningful for decoding!), the input stops with the first '='
-             if any */
+template <class InputPtr>
+concept indexes_into_byte_like = requires(InputPtr p) {
+  { std::decay_t<decltype(p[0])>{} } -> simdutf::detail::byte_like;
+};
+template <class InputPtr>
+concept indexes_into_utf16 = requires(InputPtr p) {
+  { std::decay_t<decltype(p[0])>{} } -> std::same_as<char16_t>;
+};
+template <class InputPtr>
+concept indexes_into_utf32 = requires(InputPtr p) {
+  { std::decay_t<decltype(p[0])>{} } -> std::same_as<char32_t>;
 };
 
-  #if SIMDUTF_CPLUSPLUS17
-inline std::string_view to_string(base64_options options) {
-  switch (options) {
-  case base64_default:
-    return "base64_default";
-  case base64_url:
-    return "base64_url";
-  case base64_reverse_padding:
-    return "base64_reverse_padding";
-  case base64_url_with_padding:
-    return "base64_url_with_padding";
-  case base64_default_accept_garbage:
-    return "base64_default_accept_garbage";
-  case base64_url_accept_garbage:
-    return "base64_url_accept_garbage";
-  case base64_default_or_url:
-    return "base64_default_or_url";
-  case base64_default_or_url_accept_garbage:
-    return "base64_default_or_url_accept_garbage";
-  }
-  return "<unknown>";
-}
-  #endif // SIMDUTF_CPLUSPLUS17
+template <class InputPtr>
+concept index_assignable_from_char = requires(InputPtr p, char s) {
+  { p[0] = s };
+};
 
-// last_chunk_handling_options are used to specify the handling of the last
-// chunk in base64 decoding.
-// https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
-enum last_chunk_handling_options : uint64_t {
-  loose = 0,  /* standard base64 format, decode partial final chunk */
-  strict = 1, /* error when the last chunk is partial, 2 or 3 chars, and
-                 unpadded, or non-zero bit padding */
-  stop_before_partial =
-      2, /* if the last chunk is partial, ignore it (no error) */
-  only_full_chunks =
-      3 /* only decode full blocks (4 base64 characters, no padding) */
+/**
+ * a pointer like object that results in a uint32_t when indexed.
+ * valid examples: uint32_t*
+ */
+template <class InputPtr>
+concept indexes_into_uint32 = requires(InputPtr p) {
+  { std::decay_t<decltype(p[0])>{} } -> std::same_as<std::uint32_t>;
 };
+} // namespace detail
+} // namespace simdutf
+#endif // SIMDUTF_SPAN
 
-inline bool is_partial(last_chunk_handling_options options) {
-  return (options == stop_before_partial) || (options == only_full_chunks);
+// these includes are needed for constexpr support. they are
+// not part of the public api.
+/* begin file include/simdutf/scalar/swap_bytes.h */
+#ifndef SIMDUTF_SWAP_BYTES_H
+#define SIMDUTF_SWAP_BYTES_H
+
+namespace simdutf {
+namespace scalar {
+
+constexpr inline simdutf_warn_unused uint16_t
+u16_swap_bytes(const uint16_t word) {
+  return uint16_t((word >> 8) | (word << 8));
 }
 
-  #if SIMDUTF_CPLUSPLUS17
-inline std::string_view to_string(last_chunk_handling_options options) {
-  switch (options) {
-  case loose:
-    return "loose";
-  case strict:
-    return "strict";
-  case stop_before_partial:
-    return "stop_before_partial";
-  case only_full_chunks:
-    return "only_full_chunks";
-  }
-  return "<unknown>";
+constexpr inline simdutf_warn_unused uint32_t
+u32_swap_bytes(const uint32_t word) {
+  return ((word >> 24) & 0xff) |      // move byte 3 to byte 0
+         ((word << 8) & 0xff0000) |   // move byte 1 to byte 2
+         ((word >> 8) & 0xff00) |     // move byte 2 to byte 1
+         ((word << 24) & 0xff000000); // byte 0 to byte 3
 }
-  #endif
 
-/**
- * Provide the maximal binary length in bytes given the base64 input.
- * In general, if the input contains ASCII spaces, the result will be less than
- * the maximum length.
- *
- * @param input         the base64 input to process
- * @param length        the length of the base64 input in bytes
- * @return maximum number of binary bytes
- */
-simdutf_warn_unused size_t
-maximal_binary_length_from_base64(const char *input, size_t length) noexcept;
-  #if SIMDUTF_SPAN
-simdutf_really_inline simdutf_warn_unused size_t
-maximal_binary_length_from_base64(
-    const detail::input_span_of_byte_like auto &input) noexcept {
-  return maximal_binary_length_from_base64(
-      reinterpret_cast<const char *>(input.data()), input.size());
+namespace utf32 {
+template <endianness big_endian> constexpr uint32_t swap_if_needed(uint32_t c) {
+  return !match_system(big_endian) ? scalar::u32_swap_bytes(c) : c;
 }
-  #endif // SIMDUTF_SPAN
+} // namespace utf32
 
-/**
- * Provide the maximal binary length in bytes given the base64 input.
- * In general, if the input contains ASCII spaces, the result will be less than
- * the maximum length.
- *
- * @param input         the base64 input to process, in ASCII stored as 16-bit
- * units
- * @param length        the length of the base64 input in 16-bit units
- * @return maximal number of binary bytes
- */
-simdutf_warn_unused size_t maximal_binary_length_from_base64(
-    const char16_t *input, size_t length) noexcept;
-  #if SIMDUTF_SPAN
-simdutf_really_inline simdutf_warn_unused size_t
-maximal_binary_length_from_base64(std::span<const char16_t> input) noexcept {
-  return maximal_binary_length_from_base64(input.data(), input.size());
+namespace utf16 {
+template <endianness big_endian> constexpr uint16_t swap_if_needed(uint16_t c) {
+  return !match_system(big_endian) ? scalar::u16_swap_bytes(c) : c;
 }
-  #endif // SIMDUTF_SPAN
+} // namespace utf16
 
-/**
- * Convert a base64 input to a binary output.
- *
- * This function follows the WHATWG forgiving-base64 format, which means that it
- * will ignore any ASCII spaces in the input. You may provide a padded input
- * (with one or two equal signs at the end) or an unpadded input (without any
- * equal signs at the end).
- *
- * See https://infra.spec.whatwg.org/#forgiving-base64-decode
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/swap_bytes.h */
+/* begin file include/simdutf/scalar/ascii.h */
+#ifndef SIMDUTF_ASCII_H
+#define SIMDUTF_ASCII_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace ascii {
+
+template <class InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_warn_unused simdutf_constexpr23 bool validate(InputPtr data,
+                                                      size_t len) noexcept {
+  uint64_t pos = 0;
+
+#if SIMDUTF_CPLUSPLUS23
+  // avoid memcpy during constant evaluation
+  if !consteval
+#endif
+  // process in blocks of 16 bytes when possible
+  {
+    for (; pos + 16 <= len; pos += 16) {
+      uint64_t v1;
+      std::memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      std::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v{v1 | v2};
+      if ((v & 0x8080808080808080) != 0) {
+        return false;
+      }
+    }
+  }
+
+  // process the tail byte-by-byte
+  for (; pos < len; pos++) {
+    if (static_cast<std::uint8_t>(data[pos]) >= 0b10000000) {
+      return false;
+    }
+  }
+  return true;
+}
+template <class InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_warn_unused simdutf_constexpr23 result
+validate_with_errors(InputPtr data, size_t len) noexcept {
+  size_t pos = 0;
+#if SIMDUTF_CPLUSPLUS23
+  // avoid memcpy during constant evaluation
+  if !consteval
+#endif
+  {
+    // process in blocks of 16 bytes when possible
+    for (; pos + 16 <= len; pos += 16) {
+      uint64_t v1;
+      std::memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      std::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v{v1 | v2};
+      if ((v & 0x8080808080808080) != 0) {
+        for (; pos < len; pos++) {
+          if (static_cast<std::uint8_t>(data[pos]) >= 0b10000000) {
+            return result(error_code::TOO_LARGE, pos);
+          }
+        }
+      }
+    }
+  }
+
+  // process the tail byte-by-byte
+  for (; pos < len; pos++) {
+    if (static_cast<std::uint8_t>(data[pos]) >= 0b10000000) {
+      return result(error_code::TOO_LARGE, pos);
+    }
+  }
+  return result(error_code::SUCCESS, pos);
+}
+
+} // namespace ascii
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/ascii.h */
+/* begin file include/simdutf/scalar/atomic_util.h */
+#ifndef SIMDUTF_ATOMIC_UTIL_H
+#define SIMDUTF_ATOMIC_UTIL_H
+#if SIMDUTF_ATOMIC_REF
+  #include <atomic>
+namespace simdutf {
+namespace scalar {
+
+// This function is a memcpy that uses atomic operations to read from the
+// source.
+inline void memcpy_atomic_read(char *dst, const char *src, size_t len) {
+  static_assert(std::atomic_ref<char>::required_alignment == sizeof(char),
+                "std::atomic_ref requires the same alignment as char_type");
+  // We expect all 64-bit systems to be able to read 64-bit words from an
+  // aligned memory region atomically. You might be able to do better on
+  // specific systems, e.g., x64 systems can read 128-bit words atomically.
+  constexpr size_t alignment = sizeof(uint64_t);
+
+  // Lambda for atomic byte-by-byte copy
+  auto bbb_memcpy_atomic_read = [](char *bytedst, const char *bytesrc,
+                                   size_t bytelen) noexcept {
+    char *mutable_src = const_cast<char *>(bytesrc);
+    for (size_t j = 0; j < bytelen; ++j) {
+      bytedst[j] =
+          std::atomic_ref<char>(mutable_src[j]).load(std::memory_order_relaxed);
+    }
+  };
+
+  // Handle unaligned start
+  size_t offset = reinterpret_cast<std::uintptr_t>(src) % alignment;
+  if (offset) {
+    size_t to_align = std::min(len, alignment - offset);
+    bbb_memcpy_atomic_read(dst, src, to_align);
+    src += to_align;
+    dst += to_align;
+    len -= to_align;
+  }
+
+  // Process aligned 64-bit chunks
+  while (len >= alignment) {
+    auto *src_aligned = reinterpret_cast<uint64_t *>(const_cast<char *>(src));
+    const auto dst_value =
+        std::atomic_ref<uint64_t>(*src_aligned).load(std::memory_order_relaxed);
+    std::memcpy(dst, &dst_value, sizeof(uint64_t));
+    src += alignment;
+    dst += alignment;
+    len -= alignment;
+  }
+
+  // Handle remaining bytes
+  if (len) {
+    bbb_memcpy_atomic_read(dst, src, len);
+  }
+}
+
+// This function is a memcpy that uses atomic operations to write to the
+// destination.
+inline void memcpy_atomic_write(char *dst, const char *src, size_t len) {
+  static_assert(std::atomic_ref<char>::required_alignment == sizeof(char),
+                "std::atomic_ref requires the same alignment as char");
+  // We expect all 64-bit systems to be able to write 64-bit words to an aligned
+  // memory region atomically.
+  // You might be able to do better on specific systems, e.g., x64 systems can
+  // write 128-bit words atomically.
+  constexpr size_t alignment = sizeof(uint64_t);
+
+  // Lambda for atomic byte-by-byte write
+  auto bbb_memcpy_atomic_write = [](char *bytedst, const char *bytesrc,
+                                    size_t bytelen) noexcept {
+    for (size_t j = 0; j < bytelen; ++j) {
+      std::atomic_ref<char>(bytedst[j])
+          .store(bytesrc[j], std::memory_order_relaxed);
+    }
+  };
+
+  // Handle unaligned start
+  size_t offset = reinterpret_cast<std::uintptr_t>(dst) % alignment;
+  if (offset) {
+    size_t to_align = std::min(len, alignment - offset);
+    bbb_memcpy_atomic_write(dst, src, to_align);
+    dst += to_align;
+    src += to_align;
+    len -= to_align;
+  }
+
+  // Process aligned 64-bit chunks
+  while (len >= alignment) {
+    auto *dst_aligned = reinterpret_cast<uint64_t *>(dst);
+    uint64_t src_val;
+    std::memcpy(&src_val, src, sizeof(uint64_t)); // Non-atomic read from src
+    std::atomic_ref<uint64_t>(*dst_aligned)
+        .store(src_val, std::memory_order_relaxed);
+    dst += alignment;
+    src += alignment;
+    len -= alignment;
+  }
+
+  // Handle remaining bytes
+  if (len) {
+    bbb_memcpy_atomic_write(dst, src, len);
+  }
+}
+} // namespace scalar
+} // namespace simdutf
+#endif // SIMDUTF_ATOMIC_REF
+#endif // SIMDUTF_ATOMIC_UTIL_H
+/* end file include/simdutf/scalar/atomic_util.h */
+/* begin file include/simdutf/scalar/latin1.h */
+#ifndef SIMDUTF_LATIN1_H
+#define SIMDUTF_LATIN1_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace latin1 {
+
+simdutf_really_inline size_t utf8_length_from_latin1(const char *buf,
+                                                     size_t len) {
+  const uint8_t *c = reinterpret_cast<const uint8_t *>(buf);
+  size_t answer = 0;
+  for (size_t i = 0; i < len; i++) {
+    if ((c[i] >> 7)) {
+      answer++;
+    }
+  }
+  return answer + len;
+}
+
+} // namespace latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/latin1.h */
+/* begin file include/simdutf/scalar/latin1_to_utf16/latin1_to_utf16.h */
+#ifndef SIMDUTF_LATIN1_TO_UTF16_H
+#define SIMDUTF_LATIN1_TO_UTF16_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace latin1_to_utf16 {
+
+template <endianness big_endian, typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+
+  while (pos < len) {
+    uint16_t word =
+        uint8_t(data[pos]); // extend Latin-1 char to 16-bit Unicode code point
+    *utf16_output++ =
+        char16_t(match_system(big_endian) ? word : u16_swap_bytes(word));
+    pos++;
+  }
+
+  return utf16_output - start;
+}
+
+template <endianness big_endian>
+inline result convert_with_errors(const char *buf, size_t len,
+                                  char16_t *utf16_output) {
+  const uint8_t *data = reinterpret_cast<const uint8_t *>(buf);
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+
+  while (pos < len) {
+    uint16_t word =
+        uint16_t(data[pos]); // extend Latin-1 char to 16-bit Unicode code point
+    *utf16_output++ =
+        char16_t(match_system(big_endian) ? word : u16_swap_bytes(word));
+    pos++;
+  }
+
+  return result(error_code::SUCCESS, utf16_output - start);
+}
+
+} // namespace latin1_to_utf16
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/latin1_to_utf16/latin1_to_utf16.h */
+/* begin file include/simdutf/scalar/latin1_to_utf32/latin1_to_utf32.h */
+#ifndef SIMDUTF_LATIN1_TO_UTF32_H
+#define SIMDUTF_LATIN1_TO_UTF32_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace latin1_to_utf32 {
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   char32_t *utf32_output) {
+  char32_t *start{utf32_output};
+  for (size_t i = 0; i < len; i++) {
+    *utf32_output++ = uint8_t(data[i]);
+  }
+  return utf32_output - start;
+}
+
+} // namespace latin1_to_utf32
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/latin1_to_utf32/latin1_to_utf32.h */
+/* begin file include/simdutf/scalar/latin1_to_utf8/latin1_to_utf8.h */
+#ifndef SIMDUTF_LATIN1_TO_UTF8_H
+#define SIMDUTF_LATIN1_TO_UTF8_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace latin1_to_utf8 {
+
+template <typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_byte_like<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   OutputPtr utf8_output) {
+  // const unsigned char *data = reinterpret_cast<const unsigned char *>(buf);
+  size_t pos = 0;
+  size_t utf8_pos = 0;
+
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 |
+                   v2}; // We are only interested in these bits: 1000 1000 1000
+                        // 1000, so it makes sense to concatenate everything
+        if ((v & 0x8080808080808080) ==
+            0) { // if NONE of these are set, e.g. all of them are zero, then
+                 // everything is ASCII
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            utf8_output[utf8_pos++] = char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      } // if (pos + 16 <= len)
+    } // !consteval scope
+
+    unsigned char byte = data[pos];
+    if ((byte & 0x80) == 0) { // if ASCII
+      // will generate one UTF-8 bytes
+      utf8_output[utf8_pos++] = char(byte);
+      pos++;
+    } else {
+      // will generate two UTF-8 bytes
+      utf8_output[utf8_pos++] = char((byte >> 6) | 0b11000000);
+      utf8_output[utf8_pos++] = char((byte & 0b111111) | 0b10000000);
+      pos++;
+    }
+  } // while
+  return utf8_pos;
+}
+
+simdutf_really_inline size_t convert(const char *buf, size_t len,
+                                     char *utf8_output) {
+  return convert(reinterpret_cast<const unsigned char *>(buf), len,
+                 utf8_output);
+}
+
+inline size_t convert_safe(const char *buf, size_t len, char *utf8_output,
+                           size_t utf8_len) {
+  const unsigned char *data = reinterpret_cast<const unsigned char *>(buf);
+  size_t pos = 0;
+  size_t skip_pos = 0;
+  size_t utf8_pos = 0;
+  while (pos < len && utf8_pos < utf8_len) {
+    // try to convert the next block of 16 ASCII bytes
+    if (pos >= skip_pos && pos + 16 <= len &&
+        utf8_pos + 16 <= utf8_len) { // if it is safe to read 16 more bytes,
+                                     // check that they are ascii
+      uint64_t v1;
+      ::memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v{v1 |
+                 v2}; // We are only interested in these bits: 1000 1000 1000
+                      // 1000, so it makes sense to concatenate everything
+      if ((v & 0x8080808080808080) ==
+          0) { // if NONE of these are set, e.g. all of them are zero, then
+               // everything is ASCII
+        ::memcpy(utf8_output + utf8_pos, buf + pos, 16);
+        utf8_pos += 16;
+        pos += 16;
+      } else {
+        // At least one of the next 16 bytes are not ASCII, we will process them
+        // one by one
+        skip_pos = pos + 16;
+      }
+    } else {
+      const auto byte = data[pos];
+      if ((byte & 0x80) == 0) { // if ASCII
+        // will generate one UTF-8 bytes
+        utf8_output[utf8_pos++] = char(byte);
+        pos++;
+      } else if (utf8_pos + 2 <= utf8_len) {
+        // will generate two UTF-8 bytes
+        utf8_output[utf8_pos++] = char((byte >> 6) | 0b11000000);
+        utf8_output[utf8_pos++] = char((byte & 0b111111) | 0b10000000);
+        pos++;
+      } else {
+        break;
+      }
+    }
+  }
+  return utf8_pos;
+}
+
+template <typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_byte_like<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert_safe_constexpr(InputPtr data, size_t len,
+                                                  OutputPtr utf8_output,
+                                                  size_t utf8_len) {
+  size_t pos = 0;
+  size_t utf8_pos = 0;
+  while (pos < len && utf8_pos < utf8_len) {
+    const unsigned char byte = data[pos];
+    if ((byte & 0x80) == 0) { // if ASCII
+      // will generate one UTF-8 bytes
+      utf8_output[utf8_pos++] = char(byte);
+      pos++;
+    } else if (utf8_pos + 2 <= utf8_len) {
+      // will generate two UTF-8 bytes
+      utf8_output[utf8_pos++] = char((byte >> 6) | 0b11000000);
+      utf8_output[utf8_pos++] = char((byte & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      break;
+    }
+  }
+  return utf8_pos;
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 simdutf_warn_unused size_t
+utf8_length_from_latin1(InputPtr input, size_t length) noexcept {
+  size_t answer = length;
+  size_t i = 0;
+
+#if SIMDUTF_CPLUSPLUS23
+  if !consteval
+#endif
+  {
+    auto pop = [](uint64_t v) {
+      return (size_t)(((v >> 7) & UINT64_C(0x0101010101010101)) *
+                          UINT64_C(0x0101010101010101) >>
+                      56);
+    };
+    for (; i + 32 <= length; i += 32) {
+      uint64_t v;
+      memcpy(&v, input + i, 8);
+      answer += pop(v);
+      memcpy(&v, input + i + 8, sizeof(v));
+      answer += pop(v);
+      memcpy(&v, input + i + 16, sizeof(v));
+      answer += pop(v);
+      memcpy(&v, input + i + 24, sizeof(v));
+      answer += pop(v);
+    }
+    for (; i + 8 <= length; i += 8) {
+      uint64_t v;
+      memcpy(&v, input + i, sizeof(v));
+      answer += pop(v);
+    }
+  } // !consteval scope
+  for (; i + 1 <= length; i += 1) {
+    answer += static_cast<uint8_t>(input[i]) >> 7;
+  }
+  return answer;
+}
+
+} // namespace latin1_to_utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/latin1_to_utf8/latin1_to_utf8.h */
+/* begin file include/simdutf/scalar/utf16.h */
+#ifndef SIMDUTF_UTF16_H
+#define SIMDUTF_UTF16_H
+
+namespace simdutf {
+namespace scalar {
+namespace utf16 {
+
+template <endianness big_endian>
+simdutf_warn_unused simdutf_constexpr23 bool
+validate_as_ascii(const char16_t *data, size_t len) noexcept {
+  for (size_t pos = 0; pos < len; pos++) {
+    char16_t word = scalar::utf16::swap_if_needed<big_endian>(data[pos]);
+    if (word >= 0x80) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <endianness big_endian>
+inline simdutf_warn_unused simdutf_constexpr23 bool
+validate(const char16_t *data, size_t len) noexcept {
+  uint64_t pos = 0;
+  while (pos < len) {
+    char16_t word = scalar::utf16::swap_if_needed<big_endian>(data[pos]);
+    if ((word & 0xF800) == 0xD800) {
+      if (pos + 1 >= len) {
+        return false;
+      }
+      char16_t diff = char16_t(word - 0xD800);
+      if (diff > 0x3FF) {
+        return false;
+      }
+      char16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      char16_t diff2 = char16_t(next_word - 0xDC00);
+      if (diff2 > 0x3FF) {
+        return false;
+      }
+      pos += 2;
+    } else {
+      pos++;
+    }
+  }
+  return true;
+}
+
+template <endianness big_endian>
+inline simdutf_warn_unused simdutf_constexpr23 result
+validate_with_errors(const char16_t *data, size_t len) noexcept {
+  size_t pos = 0;
+  while (pos < len) {
+    char16_t word = scalar::utf16::swap_if_needed<big_endian>(data[pos]);
+    if ((word & 0xF800) == 0xD800) {
+      if (pos + 1 >= len) {
+        return result(error_code::SURROGATE, pos);
+      }
+      char16_t diff = char16_t(word - 0xD800);
+      if (diff > 0x3FF) {
+        return result(error_code::SURROGATE, pos);
+      }
+      char16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      char16_t diff2 = uint16_t(next_word - 0xDC00);
+      if (diff2 > 0x3FF) {
+        return result(error_code::SURROGATE, pos);
+      }
+      pos += 2;
+    } else {
+      pos++;
+    }
+  }
+  return result(error_code::SUCCESS, pos);
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t count_code_points(const char16_t *p, size_t len) {
+  // We are not BOM aware.
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    char16_t word = scalar::utf16::swap_if_needed<big_endian>(p[i]);
+    counter += ((word & 0xFC00) != 0xDC00);
+  }
+  return counter;
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t utf8_length_from_utf16(const char16_t *p,
+                                                  size_t len) {
+  // We are not BOM aware.
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    char16_t word = scalar::utf16::swap_if_needed<big_endian>(p[i]);
+    counter++; // ASCII
+    counter += static_cast<size_t>(
+        word >
+        0x7F); // non-ASCII is at least 2 bytes, surrogates are 2*2 == 4 bytes
+    counter += static_cast<size_t>((word > 0x7FF && word <= 0xD7FF) ||
+                                   (word >= 0xE000)); // three-byte
+  }
+  return counter;
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t utf32_length_from_utf16(const char16_t *p,
+                                                   size_t len) {
+  // We are not BOM aware.
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    char16_t word = scalar::utf16::swap_if_needed<big_endian>(p[i]);
+    counter += ((word & 0xFC00) != 0xDC00);
+  }
+  return counter;
+}
+
+simdutf_really_inline simdutf_constexpr23 void
+change_endianness_utf16(const char16_t *input, size_t size, char16_t *output) {
+  for (size_t i = 0; i < size; i++) {
+    *output++ = char16_t(input[i] >> 8 | input[i] << 8);
+  }
+}
+
+template <endianness big_endian>
+simdutf_warn_unused simdutf_constexpr23 size_t
+trim_partial_utf16(const char16_t *input, size_t length) {
+  if (length == 0) {
+    return 0;
+  }
+  uint16_t last_word = uint16_t(input[length - 1]);
+  last_word = scalar::utf16::swap_if_needed<big_endian>(last_word);
+  length -= ((last_word & 0xFC00) == 0xD800);
+  return length;
+}
+
+template <endianness big_endian> constexpr bool is_high_surrogate(char16_t c) {
+  c = scalar::utf16::swap_if_needed<big_endian>(c);
+  return (0xd800 <= c && c <= 0xdbff);
+}
+
+template <endianness big_endian> constexpr bool is_low_surrogate(char16_t c) {
+  c = scalar::utf16::swap_if_needed<big_endian>(c);
+  return (0xdc00 <= c && c <= 0xdfff);
+}
+
+simdutf_really_inline constexpr bool high_surrogate(char16_t c) {
+  return (0xd800 <= c && c <= 0xdbff);
+}
+
+simdutf_really_inline constexpr bool low_surrogate(char16_t c) {
+  return (0xdc00 <= c && c <= 0xdfff);
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 result
+utf8_length_from_utf16_with_replacement(const char16_t *p, size_t len) {
+  bool any_surrogates = false;
+  // We are not BOM aware.
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    if (is_high_surrogate<big_endian>(p[i])) {
+      any_surrogates = true;
+      // surrogate pair
+      if (i + 1 < len && is_low_surrogate<big_endian>(p[i + 1])) {
+        counter += 4;
+        i++; // skip low surrogate
+      } else {
+        counter += 3; // unpaired high surrogate replaced by U+FFFD
+      }
+      continue;
+    } else if (is_low_surrogate<big_endian>(p[i])) {
+      any_surrogates = true;
+      counter += 3; // unpaired low surrogate replaced by U+FFFD
+      continue;
+    }
+    char16_t word = !match_system(big_endian) ? u16_swap_bytes(p[i]) : p[i];
+    counter++; // at least 1 byte
+    counter +=
+        static_cast<size_t>(word > 0x7F); // non-ASCII is at least 2 bytes
+    counter += static_cast<size_t>(word > 0x7FF); // three-byte
+  }
+  return {any_surrogates ? error_code::SURROGATE : error_code::SUCCESS,
+          counter};
+}
+
+// variable templates are a C++14 extension
+template <endianness big_endian> constexpr char16_t replacement() {
+  return !match_system(big_endian) ? scalar::u16_swap_bytes(0xfffd) : 0xfffd;
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 void to_well_formed_utf16(const char16_t *input, size_t len,
+                                              char16_t *output) {
+  const char16_t replacement = utf16::replacement<big_endian>();
+  bool high_surrogate_prev = false, high_surrogate, low_surrogate;
+  size_t i = 0;
+  for (; i < len; i++) {
+    char16_t c = input[i];
+    high_surrogate = is_high_surrogate<big_endian>(c);
+    low_surrogate = is_low_surrogate<big_endian>(c);
+    if (high_surrogate_prev && !low_surrogate) {
+      output[i - 1] = replacement;
+    }
+
+    if (!high_surrogate_prev && low_surrogate) {
+      output[i] = replacement;
+    } else {
+      output[i] = input[i];
+    }
+    high_surrogate_prev = high_surrogate;
+  }
+
+  /* string may not end with high surrogate */
+  if (high_surrogate_prev) {
+    output[i - 1] = replacement;
+  }
+}
+
+} // namespace utf16
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16.h */
+/* begin file include/simdutf/scalar/utf16_to_latin1/utf16_to_latin1.h */
+#ifndef SIMDUTF_UTF16_TO_LATIN1_H
+#define SIMDUTF_UTF16_TO_LATIN1_H
+
+#include <cstring> // for std::memcpy
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf16_to_latin1 {
+
+template <endianness big_endian, typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf16<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   OutputPtr latin_output) {
+  if (len == 0) {
+    return 0;
+  }
+  size_t pos = 0;
+  const auto latin_output_start = latin_output;
+  uint16_t word = 0;
+  uint16_t too_large = 0;
+
+  while (pos < len) {
+    word = !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    too_large |= word;
+    *latin_output++ = char(word & 0xFF);
+    pos++;
+  }
+  if ((too_large & 0xFF00) != 0) {
+    return 0;
+  }
+
+  return latin_output - latin_output_start;
+}
+
+template <endianness big_endian, typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf16<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 result convert_with_errors(InputPtr data, size_t len,
+                                               OutputPtr latin_output) {
+  if (len == 0) {
+    return result(error_code::SUCCESS, 0);
+  }
+  size_t pos = 0;
+  auto start = latin_output;
+  uint16_t word;
+
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      if (pos + 16 <= len) { // if it is safe to read 32 more bytes, check that
+                             // they are Latin1
+        uint64_t v1, v2, v3, v4;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        ::memcpy(&v2, data + pos + 4, sizeof(uint64_t));
+        ::memcpy(&v3, data + pos + 8, sizeof(uint64_t));
+        ::memcpy(&v4, data + pos + 12, sizeof(uint64_t));
+
+        if constexpr (!match_system(big_endian)) {
+          v1 = (v1 >> 8) | (v1 << (64 - 8));
+        }
+        if constexpr (!match_system(big_endian)) {
+          v2 = (v2 >> 8) | (v2 << (64 - 8));
+        }
+        if constexpr (!match_system(big_endian)) {
+          v3 = (v3 >> 8) | (v3 << (64 - 8));
+        }
+        if constexpr (!match_system(big_endian)) {
+          v4 = (v4 >> 8) | (v4 << (64 - 8));
+        }
+
+        if (((v1 | v2 | v3 | v4) & 0xFF00FF00FF00FF00) == 0) {
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *latin_output++ = !match_system(big_endian)
+                                  ? char(u16_swap_bytes(data[pos]))
+                                  : char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    word = !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xFF00) == 0) {
+      *latin_output++ = char(word & 0xFF);
+      pos++;
+    } else {
+      return result(error_code::TOO_LARGE, pos);
+    }
+  }
+  return result(error_code::SUCCESS, latin_output - start);
+}
+
+} // namespace utf16_to_latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16_to_latin1/utf16_to_latin1.h */
+/* begin file include/simdutf/scalar/utf16_to_latin1/valid_utf16_to_latin1.h */
+#ifndef SIMDUTF_VALID_UTF16_TO_LATIN1_H
+#define SIMDUTF_VALID_UTF16_TO_LATIN1_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf16_to_latin1 {
+
+template <endianness big_endian, class InputIterator, class OutputIterator>
+simdutf_constexpr23 inline size_t
+convert_valid_impl(InputIterator data, size_t len,
+                   OutputIterator latin_output) {
+  static_assert(
+      std::is_same<typename std::decay<decltype(*data)>::type, uint16_t>::value,
+      "must decay to uint16_t");
+  size_t pos = 0;
+  const auto start = latin_output;
+  uint16_t word = 0;
+
+  while (pos < len) {
+    word = !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    *latin_output++ = char(word);
+    pos++;
+  }
+
+  return latin_output - start;
+}
+
+template <endianness big_endian>
+simdutf_really_inline size_t convert_valid(const char16_t *buf, size_t len,
+                                           char *latin_output) {
+  return convert_valid_impl<big_endian>(reinterpret_cast<const uint16_t *>(buf),
+                                        len, latin_output);
+}
+} // namespace utf16_to_latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16_to_latin1/valid_utf16_to_latin1.h */
+/* begin file include/simdutf/scalar/utf16_to_utf32/utf16_to_utf32.h */
+#ifndef SIMDUTF_UTF16_TO_UTF32_H
+#define SIMDUTF_UTF16_TO_UTF32_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf16_to_utf32 {
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t convert(const char16_t *data, size_t len,
+                                   char32_t *utf32_output) {
+  size_t pos = 0;
+  char32_t *start{utf32_output};
+  while (pos < len) {
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xF800) != 0xD800) {
+      // No surrogate pair, extend 16-bit word to 32-bit word
+      *utf32_output++ = char32_t(word);
+      pos++;
+    } else {
+      // must be a surrogate pair
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (diff > 0x3FF) {
+        return 0;
+      }
+      if (pos + 1 >= len) {
+        return 0;
+      } // minimal bound checking
+      uint16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      uint16_t diff2 = uint16_t(next_word - 0xDC00);
+      if (diff2 > 0x3FF) {
+        return 0;
+      }
+      uint32_t value = (diff << 10) + diff2 + 0x10000;
+      *utf32_output++ = char32_t(value);
+      pos += 2;
+    }
+  }
+  return utf32_output - start;
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 result convert_with_errors(const char16_t *data, size_t len,
+                                               char32_t *utf32_output) {
+  size_t pos = 0;
+  char32_t *start{utf32_output};
+  while (pos < len) {
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xF800) != 0xD800) {
+      // No surrogate pair, extend 16-bit word to 32-bit word
+      *utf32_output++ = char32_t(word);
+      pos++;
+    } else {
+      // must be a surrogate pair
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (diff > 0x3FF) {
+        return result(error_code::SURROGATE, pos);
+      }
+      if (pos + 1 >= len) {
+        return result(error_code::SURROGATE, pos);
+      } // minimal bound checking
+      uint16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      uint16_t diff2 = uint16_t(next_word - 0xDC00);
+      if (diff2 > 0x3FF) {
+        return result(error_code::SURROGATE, pos);
+      }
+      uint32_t value = (diff << 10) + diff2 + 0x10000;
+      *utf32_output++ = char32_t(value);
+      pos += 2;
+    }
+  }
+  return result(error_code::SUCCESS, utf32_output - start);
+}
+
+} // namespace utf16_to_utf32
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16_to_utf32/utf16_to_utf32.h */
+/* begin file include/simdutf/scalar/utf16_to_utf32/valid_utf16_to_utf32.h */
+#ifndef SIMDUTF_VALID_UTF16_TO_UTF32_H
+#define SIMDUTF_VALID_UTF16_TO_UTF32_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf16_to_utf32 {
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t convert_valid(const char16_t *data, size_t len,
+                                         char32_t *utf32_output) {
+  size_t pos = 0;
+  char32_t *start{utf32_output};
+  while (pos < len) {
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xF800) != 0xD800) {
+      // No surrogate pair, extend 16-bit word to 32-bit word
+      *utf32_output++ = char32_t(word);
+      pos++;
+    } else {
+      // must be a surrogate pair
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (pos + 1 >= len) {
+        return 0;
+      } // minimal bound checking
+      uint16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      uint16_t diff2 = uint16_t(next_word - 0xDC00);
+      uint32_t value = (diff << 10) + diff2 + 0x10000;
+      *utf32_output++ = char32_t(value);
+      pos += 2;
+    }
+  }
+  return utf32_output - start;
+}
+
+} // namespace utf16_to_utf32
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16_to_utf32/valid_utf16_to_utf32.h */
+/* begin file include/simdutf/scalar/utf16_to_utf8/utf16_to_utf8.h */
+#ifndef SIMDUTF_UTF16_TO_UTF8_H
+#define SIMDUTF_UTF16_TO_UTF8_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf16_to_utf8 {
+
+template <endianness big_endian, typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_utf16<InputPtr>
+// FIXME constrain output as well
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   OutputPtr utf8_output) {
+  size_t pos = 0;
+  const auto start = utf8_output;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 8 bytes
+      if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if constexpr (!match_system(big_endian)) {
+          v = (v >> 8) | (v << (64 - 8));
+        }
+        if ((v & 0xFF80FF80FF80FF80) == 0) {
+          size_t final_pos = pos + 4;
+          while (pos < final_pos) {
+            *utf8_output++ = !match_system(big_endian)
+                                 ? char(u16_swap_bytes(data[pos]))
+                                 : char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xFF80) == 0) {
+      // will generate one UTF-8 bytes
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else if ((word & 0xF800) != 0xD800) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      // must be a surrogate pair
+      if (pos + 1 >= len) {
+        return 0;
+      }
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (diff > 0x3FF) {
+        return 0;
+      }
+      uint16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      uint16_t diff2 = uint16_t(next_word - 0xDC00);
+      if (diff2 > 0x3FF) {
+        return 0;
+      }
+      uint32_t value = (diff << 10) + diff2 + 0x10000;
+      // will generate four UTF-8 bytes
+      // we have 0b11110XXX 0b10XXXXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((value >> 18) | 0b11110000);
+      *utf8_output++ = char(((value >> 12) & 0b111111) | 0b10000000);
+      *utf8_output++ = char(((value >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((value & 0b111111) | 0b10000000);
+      pos += 2;
+    }
+  }
+  return utf8_output - start;
+}
+
+template <endianness big_endian, bool check_output = false, typename InputPtr,
+          typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf16<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 full_result convert_with_errors(InputPtr data, size_t len,
+                                                    OutputPtr utf8_output,
+                                                    size_t utf8_len = 0) {
+  if (check_output && utf8_len == 0) {
+    return full_result(error_code::OUTPUT_BUFFER_TOO_SMALL, 0, 0);
+  }
+
+  size_t pos = 0;
+  auto start = utf8_output;
+  auto end = utf8_output + utf8_len;
+
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 8 bytes
+      if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if constexpr (!match_system(big_endian))
+          v = (v >> 8) | (v << (64 - 8));
+        if ((v & 0xFF80FF80FF80FF80) == 0) {
+          size_t final_pos = pos + 4;
+          while (pos < final_pos) {
+            if (check_output && size_t(end - utf8_output) < 1) {
+              return full_result(error_code::OUTPUT_BUFFER_TOO_SMALL, pos,
+                                 utf8_output - start);
+            }
+            *utf8_output++ = !match_system(big_endian)
+                                 ? char(u16_swap_bytes(data[pos]))
+                                 : char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xFF80) == 0) {
+      // will generate one UTF-8 bytes
+      if (check_output && size_t(end - utf8_output) < 1) {
+        return full_result(error_code::OUTPUT_BUFFER_TOO_SMALL, pos,
+                           utf8_output - start);
+      }
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      if (check_output && size_t(end - utf8_output) < 2) {
+        return full_result(error_code::OUTPUT_BUFFER_TOO_SMALL, pos,
+                           utf8_output - start);
+      }
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+
+    } else if ((word & 0xF800) != 0xD800) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      if (check_output && size_t(end - utf8_output) < 3) {
+        return full_result(error_code::OUTPUT_BUFFER_TOO_SMALL, pos,
+                           utf8_output - start);
+      }
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+
+      if (check_output && size_t(end - utf8_output) < 4) {
+        return full_result(error_code::OUTPUT_BUFFER_TOO_SMALL, pos,
+                           utf8_output - start);
+      }
+      // must be a surrogate pair
+      if (pos + 1 >= len) {
+        return full_result(error_code::SURROGATE, pos, utf8_output - start);
+      }
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (diff > 0x3FF) {
+        return full_result(error_code::SURROGATE, pos, utf8_output - start);
+      }
+      uint16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      uint16_t diff2 = uint16_t(next_word - 0xDC00);
+      if (diff2 > 0x3FF) {
+        return full_result(error_code::SURROGATE, pos, utf8_output - start);
+      }
+      uint32_t value = (diff << 10) + diff2 + 0x10000;
+      // will generate four UTF-8 bytes
+      // we have 0b11110XXX 0b10XXXXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((value >> 18) | 0b11110000);
+      *utf8_output++ = char(((value >> 12) & 0b111111) | 0b10000000);
+      *utf8_output++ = char(((value >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((value & 0b111111) | 0b10000000);
+      pos += 2;
+    }
+  }
+  return full_result(error_code::SUCCESS, pos, utf8_output - start);
+}
+
+template <endianness big_endian>
+inline result simple_convert_with_errors(const char16_t *buf, size_t len,
+                                         char *utf8_output) {
+  return convert_with_errors<big_endian, false>(buf, len, utf8_output, 0);
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t convert_with_replacement(const char16_t *data,
+                                                    size_t len,
+                                                    char *utf8_output) {
+  size_t pos = 0;
+  char *start = utf8_output;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 8 bytes
+      if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if constexpr (!match_system(big_endian)) {
+          v = (v >> 8) | (v << (64 - 8));
+        }
+        if ((v & 0xFF80FF80FF80FF80) == 0) {
+          size_t final_pos = pos + 4;
+          while (pos < final_pos) {
+            *utf8_output++ = !match_system(big_endian)
+                                 ? char(u16_swap_bytes(data[pos]))
+                                 : char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xFF80) == 0) {
+      // will generate one UTF-8 bytes
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else if ((word & 0xF800) != 0xD800) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      // surrogate range
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (diff <= 0x3FF && pos + 1 < len) {
+        // high surrogate, check for valid pair
+        uint16_t next_word = !match_system(big_endian)
+                                 ? u16_swap_bytes(data[pos + 1])
+                                 : data[pos + 1];
+        uint16_t diff2 = uint16_t(next_word - 0xDC00);
+        if (diff2 <= 0x3FF) {
+          // valid surrogate pair
+          uint32_t value = (diff << 10) + diff2 + 0x10000;
+          // will generate four UTF-8 bytes
+          *utf8_output++ = char((value >> 18) | 0b11110000);
+          *utf8_output++ = char(((value >> 12) & 0b111111) | 0b10000000);
+          *utf8_output++ = char(((value >> 6) & 0b111111) | 0b10000000);
+          *utf8_output++ = char((value & 0b111111) | 0b10000000);
+          pos += 2;
+          continue;
+        }
+      }
+      // unpaired surrogate: replace with U+FFFD (0xEF 0xBF 0xBD)
+      *utf8_output++ = char(0xef);
+      *utf8_output++ = char(0xbf);
+      *utf8_output++ = char(0xbd);
+      pos++;
+    }
+  }
+  return utf8_output - start;
+}
+
+} // namespace utf16_to_utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16_to_utf8/utf16_to_utf8.h */
+/* begin file include/simdutf/scalar/utf16_to_utf8/valid_utf16_to_utf8.h */
+#ifndef SIMDUTF_VALID_UTF16_TO_UTF8_H
+#define SIMDUTF_VALID_UTF16_TO_UTF8_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf16_to_utf8 {
+
+template <endianness big_endian, typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf16<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert_valid(InputPtr data, size_t len,
+                                         OutputPtr utf8_output) {
+  size_t pos = 0;
+  auto start = utf8_output;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 4 ASCII characters
+      if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if constexpr (!match_system(big_endian)) {
+          v = (v >> 8) | (v << (64 - 8));
+        }
+        if ((v & 0xFF80FF80FF80FF80) == 0) {
+          size_t final_pos = pos + 4;
+          while (pos < final_pos) {
+            *utf8_output++ = !match_system(big_endian)
+                                 ? char(u16_swap_bytes(data[pos]))
+                                 : char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    uint16_t word =
+        !match_system(big_endian) ? u16_swap_bytes(data[pos]) : data[pos];
+    if ((word & 0xFF80) == 0) {
+      // will generate one UTF-8 bytes
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else if ((word & 0xF800) != 0xD800) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      // must be a surrogate pair
+      uint16_t diff = uint16_t(word - 0xD800);
+      if (pos + 1 >= len) {
+        return 0;
+      } // minimal bound checking
+      uint16_t next_word = !match_system(big_endian)
+                               ? u16_swap_bytes(data[pos + 1])
+                               : data[pos + 1];
+      uint16_t diff2 = uint16_t(next_word - 0xDC00);
+      uint32_t value = (diff << 10) + diff2 + 0x10000;
+      // will generate four UTF-8 bytes
+      // we have 0b11110XXX 0b10XXXXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((value >> 18) | 0b11110000);
+      *utf8_output++ = char(((value >> 12) & 0b111111) | 0b10000000);
+      *utf8_output++ = char(((value >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((value & 0b111111) | 0b10000000);
+      pos += 2;
+    }
+  }
+  return utf8_output - start;
+}
+
+} // namespace utf16_to_utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf16_to_utf8/valid_utf16_to_utf8.h */
+/* begin file include/simdutf/scalar/utf32.h */
+#ifndef SIMDUTF_UTF32_H
+#define SIMDUTF_UTF32_H
+
+namespace simdutf {
+namespace scalar {
+namespace utf32 {
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_uint32<InputPtr>
+#endif
+simdutf_warn_unused simdutf_constexpr23 bool validate(InputPtr data,
+                                                      size_t len) noexcept {
+  uint64_t pos = 0;
+  for (; pos < len; pos++) {
+    uint32_t word = data[pos];
+    if (word > 0x10FFFF || (word >= 0xD800 && word <= 0xDFFF)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+simdutf_warn_unused simdutf_really_inline bool validate(const char32_t *buf,
+                                                        size_t len) noexcept {
+  return validate(reinterpret_cast<const uint32_t *>(buf), len);
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_uint32<InputPtr>
+#endif
+simdutf_warn_unused simdutf_constexpr23 result
+validate_with_errors(InputPtr data, size_t len) noexcept {
+  size_t pos = 0;
+  for (; pos < len; pos++) {
+    uint32_t word = data[pos];
+    if (word > 0x10FFFF) {
+      return result(error_code::TOO_LARGE, pos);
+    }
+    if (word >= 0xD800 && word <= 0xDFFF) {
+      return result(error_code::SURROGATE, pos);
+    }
+  }
+  return result(error_code::SUCCESS, pos);
+}
+
+simdutf_warn_unused simdutf_really_inline result
+validate_with_errors(const char32_t *buf, size_t len) noexcept {
+  return validate_with_errors(reinterpret_cast<const uint32_t *>(buf), len);
+}
+
+inline simdutf_constexpr23 size_t utf8_length_from_utf32(const char32_t *p,
+                                                         size_t len) {
+  // We are not BOM aware.
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    // credit: @ttsugriy  for the vectorizable approach
+    counter++;                                     // ASCII
+    counter += static_cast<size_t>(p[i] > 0x7F);   // two-byte
+    counter += static_cast<size_t>(p[i] > 0x7FF);  // three-byte
+    counter += static_cast<size_t>(p[i] > 0xFFFF); // four-bytes
+  }
+  return counter;
+}
+
+inline simdutf_warn_unused simdutf_constexpr23 size_t
+utf16_length_from_utf32(const char32_t *p, size_t len) {
+  // We are not BOM aware.
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    counter++;                                     // non-surrogate word
+    counter += static_cast<size_t>(p[i] > 0xFFFF); // surrogate pair
+  }
+  return counter;
+}
+
+} // namespace utf32
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32.h */
+/* begin file include/simdutf/scalar/utf32_to_latin1/utf32_to_latin1.h */
+#ifndef SIMDUTF_UTF32_TO_LATIN1_H
+#define SIMDUTF_UTF32_TO_LATIN1_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf32_to_latin1 {
+
+inline simdutf_constexpr23 size_t convert(const char32_t *data, size_t len,
+                                          char *latin1_output) {
+  char *start = latin1_output;
+  uint32_t utf32_char;
+  size_t pos = 0;
+  uint32_t too_large = 0;
+
+  while (pos < len) {
+    utf32_char = (uint32_t)data[pos];
+    too_large |= utf32_char;
+    *latin1_output++ = (char)(utf32_char & 0xFF);
+    pos++;
+  }
+  if ((too_large & 0xFFFFFF00) != 0) {
+    return 0;
+  }
+  return latin1_output - start;
+}
+
+inline simdutf_constexpr23 result convert_with_errors(const char32_t *data,
+                                                      size_t len,
+                                                      char *latin1_output) {
+  char *start{latin1_output};
+  size_t pos = 0;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are Latin1
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0xFFFFFF00FFFFFF00) == 0) {
+          *latin1_output++ = char(data[pos]);
+          *latin1_output++ = char(data[pos + 1]);
+          pos += 2;
+          continue;
+        }
+      }
+    }
+
+    uint32_t utf32_char = data[pos];
+    if ((utf32_char & 0xFFFFFF00) ==
+        0) { // Check if the character can be represented in Latin-1
+      *latin1_output++ = (char)(utf32_char & 0xFF);
+      pos++;
+    } else {
+      return result(error_code::TOO_LARGE, pos);
+    };
+  }
+  return result(error_code::SUCCESS, latin1_output - start);
+}
+
+} // namespace utf32_to_latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32_to_latin1/utf32_to_latin1.h */
+/* begin file include/simdutf/scalar/utf32_to_latin1/valid_utf32_to_latin1.h */
+#ifndef SIMDUTF_VALID_UTF32_TO_LATIN1_H
+#define SIMDUTF_VALID_UTF32_TO_LATIN1_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf32_to_latin1 {
+
+template <typename ReadPtr, typename WritePtr>
+simdutf_constexpr23 size_t convert_valid(ReadPtr data, size_t len,
+                                         WritePtr latin1_output) {
+  static_assert(
+      std::is_same<typename std::decay<decltype(*data)>::type, uint32_t>::value,
+      "dereferencing the data pointer must result in a uint32_t");
+  auto start = latin1_output;
+  uint32_t utf32_char;
+  size_t pos = 0;
+
+  while (pos < len) {
+    utf32_char = data[pos];
+
+#if SIMDUTF_CPLUSPLUS23
+    // avoid using the 8 byte at a time optimization in constant evaluation
+    // mode. memcpy can't be used and replacing it with bitwise or gave worse
+    // codegen (when not during constant evaluation).
+    if !consteval {
+#endif
+      if (pos + 2 <= len) {
+        // if it is safe to read 8 more bytes, check that they are Latin1
+        uint64_t v;
+        std::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0xFFFFFF00FFFFFF00) == 0) {
+          *latin1_output++ = char(data[pos]);
+          *latin1_output++ = char(data[pos + 1]);
+          pos += 2;
+          continue;
+        } else {
+          // output can not be represented in latin1
+          return 0;
+        }
+      }
+#if SIMDUTF_CPLUSPLUS23
+    } // if ! consteval
+#endif
+    if ((utf32_char & 0xFFFFFF00) == 0) {
+      *latin1_output++ = char(utf32_char);
+    } else {
+      // output can not be represented in latin1
+      return 0;
+    }
+    pos++;
+  }
+  return latin1_output - start;
+}
+
+simdutf_really_inline size_t convert_valid(const char32_t *buf, size_t len,
+                                           char *latin1_output) {
+  return convert_valid(reinterpret_cast<const uint32_t *>(buf), len,
+                       latin1_output);
+}
+
+} // namespace utf32_to_latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32_to_latin1/valid_utf32_to_latin1.h */
+/* begin file include/simdutf/scalar/utf32_to_utf16/utf32_to_utf16.h */
+#ifndef SIMDUTF_UTF32_TO_UTF16_H
+#define SIMDUTF_UTF32_TO_UTF16_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf32_to_utf16 {
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t convert(const char32_t *data, size_t len,
+                                   char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+  while (pos < len) {
+    uint32_t word = data[pos];
+    if ((word & 0xFFFF0000) == 0) {
+      if (word >= 0xD800 && word <= 0xDFFF) {
+        return 0;
+      }
+      // will not generate a surrogate pair
+      *utf16_output++ = !match_system(big_endian)
+                            ? char16_t(u16_swap_bytes(uint16_t(word)))
+                            : char16_t(word);
+    } else {
+      // will generate a surrogate pair
+      if (word > 0x10FFFF) {
+        return 0;
+      }
+      word -= 0x10000;
+      uint16_t high_surrogate = uint16_t(0xD800 + (word >> 10));
+      uint16_t low_surrogate = uint16_t(0xDC00 + (word & 0x3FF));
+      if constexpr (!match_system(big_endian)) {
+        high_surrogate = u16_swap_bytes(high_surrogate);
+        low_surrogate = u16_swap_bytes(low_surrogate);
+      }
+      *utf16_output++ = char16_t(high_surrogate);
+      *utf16_output++ = char16_t(low_surrogate);
+    }
+    pos++;
+  }
+  return utf16_output - start;
+}
+
+template <endianness big_endian>
+simdutf_constexpr23 result convert_with_errors(const char32_t *data, size_t len,
+                                               char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+  while (pos < len) {
+    uint32_t word = data[pos];
+    if ((word & 0xFFFF0000) == 0) {
+      if (word >= 0xD800 && word <= 0xDFFF) {
+        return result(error_code::SURROGATE, pos);
+      }
+      // will not generate a surrogate pair
+      *utf16_output++ = !match_system(big_endian)
+                            ? char16_t(u16_swap_bytes(uint16_t(word)))
+                            : char16_t(word);
+    } else {
+      // will generate a surrogate pair
+      if (word > 0x10FFFF) {
+        return result(error_code::TOO_LARGE, pos);
+      }
+      word -= 0x10000;
+      uint16_t high_surrogate = uint16_t(0xD800 + (word >> 10));
+      uint16_t low_surrogate = uint16_t(0xDC00 + (word & 0x3FF));
+      if constexpr (!match_system(big_endian)) {
+        high_surrogate = u16_swap_bytes(high_surrogate);
+        low_surrogate = u16_swap_bytes(low_surrogate);
+      }
+      *utf16_output++ = char16_t(high_surrogate);
+      *utf16_output++ = char16_t(low_surrogate);
+    }
+    pos++;
+  }
+  return result(error_code::SUCCESS, utf16_output - start);
+}
+
+} // namespace utf32_to_utf16
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32_to_utf16/utf32_to_utf16.h */
+/* begin file include/simdutf/scalar/utf32_to_utf16/valid_utf32_to_utf16.h */
+#ifndef SIMDUTF_VALID_UTF32_TO_UTF16_H
+#define SIMDUTF_VALID_UTF32_TO_UTF16_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf32_to_utf16 {
+
+template <endianness big_endian>
+simdutf_constexpr23 size_t convert_valid(const char32_t *data, size_t len,
+                                         char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+  while (pos < len) {
+    uint32_t word = data[pos];
+    if ((word & 0xFFFF0000) == 0) {
+      // will not generate a surrogate pair
+      *utf16_output++ = !match_system(big_endian)
+                            ? char16_t(u16_swap_bytes(uint16_t(word)))
+                            : char16_t(word);
+      pos++;
+    } else {
+      // will generate a surrogate pair
+      word -= 0x10000;
+      uint16_t high_surrogate = uint16_t(0xD800 + (word >> 10));
+      uint16_t low_surrogate = uint16_t(0xDC00 + (word & 0x3FF));
+      if constexpr (!match_system(big_endian)) {
+        high_surrogate = u16_swap_bytes(high_surrogate);
+        low_surrogate = u16_swap_bytes(low_surrogate);
+      }
+      *utf16_output++ = char16_t(high_surrogate);
+      *utf16_output++ = char16_t(low_surrogate);
+      pos++;
+    }
+  }
+  return utf16_output - start;
+}
+
+} // namespace utf32_to_utf16
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32_to_utf16/valid_utf32_to_utf16.h */
+/* begin file include/simdutf/scalar/utf32_to_utf8/utf32_to_utf8.h */
+#ifndef SIMDUTF_UTF32_TO_UTF8_H
+#define SIMDUTF_UTF32_TO_UTF8_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf32_to_utf8 {
+
+template <typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf32<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   OutputPtr utf8_output) {
+  size_t pos = 0;
+  auto start = utf8_output;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    { // try to convert the next block of 2 ASCII characters
+      if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0xFFFFFF80FFFFFF80) == 0) {
+          *utf8_output++ = char(data[pos]);
+          *utf8_output++ = char(data[pos + 1]);
+          pos += 2;
+          continue;
+        }
+      }
+    }
+
+    uint32_t word = data[pos];
+    if ((word & 0xFFFFFF80) == 0) {
+      // will generate one UTF-8 bytes
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xFFFFF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else if ((word & 0xFFFF0000) == 0) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      if (word >= 0xD800 && word <= 0xDFFF) {
+        return 0;
+      }
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      // will generate four UTF-8 bytes
+      // we have 0b11110XXX 0b10XXXXXX 0b10XXXXXX 0b10XXXXXX
+      if (word > 0x10FFFF) {
+        return 0;
+      }
+      *utf8_output++ = char((word >> 18) | 0b11110000);
+      *utf8_output++ = char(((word >> 12) & 0b111111) | 0b10000000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    }
+  }
+  return utf8_output - start;
+}
+
+template <typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf32<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 result convert_with_errors(InputPtr data, size_t len,
+                                               OutputPtr utf8_output) {
+  size_t pos = 0;
+  auto start = utf8_output;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    { // try to convert the next block of 2 ASCII characters
+      if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0xFFFFFF80FFFFFF80) == 0) {
+          *utf8_output++ = char(data[pos]);
+          *utf8_output++ = char(data[pos + 1]);
+          pos += 2;
+          continue;
+        }
+      }
+    }
+
+    uint32_t word = data[pos];
+    if ((word & 0xFFFFFF80) == 0) {
+      // will generate one UTF-8 bytes
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xFFFFF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else if ((word & 0xFFFF0000) == 0) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      if (word >= 0xD800 && word <= 0xDFFF) {
+        return result(error_code::SURROGATE, pos);
+      }
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      // will generate four UTF-8 bytes
+      // we have 0b11110XXX 0b10XXXXXX 0b10XXXXXX 0b10XXXXXX
+      if (word > 0x10FFFF) {
+        return result(error_code::TOO_LARGE, pos);
+      }
+      *utf8_output++ = char((word >> 18) | 0b11110000);
+      *utf8_output++ = char(((word >> 12) & 0b111111) | 0b10000000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    }
+  }
+  return result(error_code::SUCCESS, utf8_output - start);
+}
+
+} // namespace utf32_to_utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32_to_utf8/utf32_to_utf8.h */
+/* begin file include/simdutf/scalar/utf32_to_utf8/valid_utf32_to_utf8.h */
+#ifndef SIMDUTF_VALID_UTF32_TO_UTF8_H
+#define SIMDUTF_VALID_UTF32_TO_UTF8_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf32_to_utf8 {
+
+template <typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_utf32<InputPtr> &&
+           simdutf::detail::index_assignable_from_char<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert_valid(InputPtr data, size_t len,
+                                         OutputPtr utf8_output) {
+  size_t pos = 0;
+  auto start = utf8_output;
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    { // try to convert the next block of 2 ASCII characters
+      if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0xFFFFFF80FFFFFF80) == 0) {
+          *utf8_output++ = char(data[pos]);
+          *utf8_output++ = char(data[pos + 1]);
+          pos += 2;
+          continue;
+        }
+      }
+    }
+
+    uint32_t word = data[pos];
+    if ((word & 0xFFFFFF80) == 0) {
+      // will generate one UTF-8 bytes
+      *utf8_output++ = char(word);
+      pos++;
+    } else if ((word & 0xFFFFF800) == 0) {
+      // will generate two UTF-8 bytes
+      // we have 0b110XXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 6) | 0b11000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else if ((word & 0xFFFF0000) == 0) {
+      // will generate three UTF-8 bytes
+      // we have 0b1110XXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 12) | 0b11100000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    } else {
+      // will generate four UTF-8 bytes
+      // we have 0b11110XXX 0b10XXXXXX 0b10XXXXXX 0b10XXXXXX
+      *utf8_output++ = char((word >> 18) | 0b11110000);
+      *utf8_output++ = char(((word >> 12) & 0b111111) | 0b10000000);
+      *utf8_output++ = char(((word >> 6) & 0b111111) | 0b10000000);
+      *utf8_output++ = char((word & 0b111111) | 0b10000000);
+      pos++;
+    }
+  }
+  return utf8_output - start;
+}
+
+} // namespace utf32_to_utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf32_to_utf8/valid_utf32_to_utf8.h */
+/* begin file include/simdutf/scalar/utf8.h */
+#ifndef SIMDUTF_UTF8_H
+#define SIMDUTF_UTF8_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8 {
+
+// credit: based on code from Google Fuchsia (Apache Licensed)
+template <class BytePtr>
+simdutf_constexpr23 simdutf_warn_unused bool validate(BytePtr data,
+                                                      size_t len) noexcept {
+  static_assert(
+      std::is_same<typename std::decay<decltype(*data)>::type, uint8_t>::value,
+      "dereferencing the data pointer must result in a uint8_t");
+  uint64_t pos = 0;
+  uint32_t code_point = 0;
+  while (pos < len) {
+    uint64_t next_pos;
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    { // check if the next 16 bytes are ascii.
+      next_pos = pos + 16;
+      if (next_pos <= len) { // if it is safe to read 16 more bytes, check
+                             // that they are ascii
+        uint64_t v1{};
+        std::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2{};
+        std::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2};
+        if ((v & 0x8080808080808080) == 0) {
+          pos = next_pos;
+          continue;
+        }
+      }
+    }
+
+    unsigned char byte = data[pos];
+
+    while (byte < 0b10000000) {
+      if (++pos == len) {
+        return true;
+      }
+      byte = data[pos];
+    }
+
+    if ((byte & 0b11100000) == 0b11000000) {
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if ((code_point < 0x80) || (0x7ff < code_point)) {
+        return false;
+      }
+    } else if ((byte & 0b11110000) == 0b11100000) {
+      next_pos = pos + 3;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point = (byte & 0b00001111) << 12 |
+                   (data[pos + 1] & 0b00111111) << 6 |
+                   (data[pos + 2] & 0b00111111);
+      if ((code_point < 0x800) || (0xffff < code_point) ||
+          (0xd7ff < code_point && code_point < 0xe000)) {
+        return false;
+      }
+    } else if ((byte & 0b11111000) == 0b11110000) { // 0b11110000
+      next_pos = pos + 4;
+      if (next_pos > len) {
+        return false;
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return false;
+      }
+      // range check
+      code_point =
+          (byte & 0b00000111) << 18 | (data[pos + 1] & 0b00111111) << 12 |
+          (data[pos + 2] & 0b00111111) << 6 | (data[pos + 3] & 0b00111111);
+      if (code_point <= 0xffff || 0x10ffff < code_point) {
+        return false;
+      }
+    } else {
+      // we may have a continuation
+      return false;
+    }
+    pos = next_pos;
+  }
+  return true;
+}
+
+simdutf_really_inline simdutf_warn_unused bool validate(const char *buf,
+                                                        size_t len) noexcept {
+  return validate(reinterpret_cast<const uint8_t *>(buf), len);
+}
+
+template <class BytePtr>
+simdutf_constexpr23 simdutf_warn_unused result
+validate_with_errors(BytePtr data, size_t len) noexcept {
+  static_assert(
+      std::is_same<typename std::decay<decltype(*data)>::type, uint8_t>::value,
+      "dereferencing the data pointer must result in a uint8_t");
+  size_t pos = 0;
+  uint32_t code_point = 0;
+  while (pos < len) {
+    // check of the next 16 bytes are ascii.
+    size_t next_pos = pos + 16;
+    if (next_pos <=
+        len) { // if it is safe to read 16 more bytes, check that they are ascii
+      uint64_t v1;
+      std::memcpy(&v1, data + pos, sizeof(uint64_t));
+      uint64_t v2;
+      std::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+      uint64_t v{v1 | v2};
+      if ((v & 0x8080808080808080) == 0) {
+        pos = next_pos;
+        continue;
+      }
+    }
+    unsigned char byte = data[pos];
+
+    while (byte < 0b10000000) {
+      if (++pos == len) {
+        return result(error_code::SUCCESS, len);
+      }
+      byte = data[pos];
+    }
+
+    if ((byte & 0b11100000) == 0b11000000) {
+      next_pos = pos + 2;
+      if (next_pos > len) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      code_point = (byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if ((code_point < 0x80) || (0x7ff < code_point)) {
+        return result(error_code::OVERLONG, pos);
+      }
+    } else if ((byte & 0b11110000) == 0b11100000) {
+      next_pos = pos + 3;
+      if (next_pos > len) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      code_point = (byte & 0b00001111) << 12 |
+                   (data[pos + 1] & 0b00111111) << 6 |
+                   (data[pos + 2] & 0b00111111);
+      if ((code_point < 0x800) || (0xffff < code_point)) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0xd7ff < code_point && code_point < 0xe000) {
+        return result(error_code::SURROGATE, pos);
+      }
+    } else if ((byte & 0b11111000) == 0b11110000) { // 0b11110000
+      next_pos = pos + 4;
+      if (next_pos > len) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      code_point =
+          (byte & 0b00000111) << 18 | (data[pos + 1] & 0b00111111) << 12 |
+          (data[pos + 2] & 0b00111111) << 6 | (data[pos + 3] & 0b00111111);
+      if (code_point <= 0xffff) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0x10ffff < code_point) {
+        return result(error_code::TOO_LARGE, pos);
+      }
+    } else {
+      // we either have too many continuation bytes or an invalid leading byte
+      if ((byte & 0b11000000) == 0b10000000) {
+        return result(error_code::TOO_LONG, pos);
+      } else {
+        return result(error_code::HEADER_BITS, pos);
+      }
+    }
+    pos = next_pos;
+  }
+  return result(error_code::SUCCESS, len);
+}
+
+simdutf_really_inline simdutf_warn_unused result
+validate_with_errors(const char *buf, size_t len) noexcept {
+  return validate_with_errors(reinterpret_cast<const uint8_t *>(buf), len);
+}
+
+// Finds the previous leading byte starting backward from buf and validates with
+// errors from there Used to pinpoint the location of an error when an invalid
+// chunk is detected We assume that the stream starts with a leading byte, and
+// to check that it is the case, we ask that you pass a pointer to the start of
+// the stream (start).
+inline simdutf_warn_unused result rewind_and_validate_with_errors(
+    const char *start, const char *buf, size_t len) noexcept {
+  // First check that we start with a leading byte
+  if ((*start & 0b11000000) == 0b10000000) {
+    return result(error_code::TOO_LONG, 0);
+  }
+  size_t extra_len{0};
+  // A leading byte cannot be further than 4 bytes away
+  for (int i = 0; i < 5; i++) {
+    unsigned char byte = *buf;
+    if ((byte & 0b11000000) != 0b10000000) {
+      break;
+    } else {
+      buf--;
+      extra_len++;
+    }
+  }
+
+  result res = validate_with_errors(buf, len + extra_len);
+  res.count -= extra_len;
+  return res;
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t count_code_points(InputPtr data, size_t len) {
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    // -65 is 0b10111111, anything larger in two-complement's should start a new
+    // code point.
+    if (int8_t(data[i]) > -65) {
+      counter++;
+    }
+  }
+  return counter;
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t utf16_length_from_utf8(InputPtr data, size_t len) {
+  size_t counter{0};
+  for (size_t i = 0; i < len; i++) {
+    if (int8_t(data[i]) > -65) {
+      counter++;
+    }
+    if (uint8_t(data[i]) >= 240) {
+      counter++;
+    }
+  }
+  return counter;
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_warn_unused simdutf_constexpr23 size_t
+trim_partial_utf8(InputPtr input, size_t length) {
+  if (length < 3) {
+    switch (length) {
+    case 2:
+      if (uint8_t(input[length - 1]) >= 0xc0) {
+        return length - 1;
+      } // 2-, 3- and 4-byte characters with only 1 byte left
+      if (uint8_t(input[length - 2]) >= 0xe0) {
+        return length - 2;
+      } // 3- and 4-byte characters with only 2 bytes left
+      return length;
+    case 1:
+      if (uint8_t(input[length - 1]) >= 0xc0) {
+        return length - 1;
+      } // 2-, 3- and 4-byte characters with only 1 byte left
+      return length;
+    case 0:
+      return length;
+    }
+  }
+  if (uint8_t(input[length - 1]) >= 0xc0) {
+    return length - 1;
+  } // 2-, 3- and 4-byte characters with only 1 byte left
+  if (uint8_t(input[length - 2]) >= 0xe0) {
+    return length - 2;
+  } // 3- and 4-byte characters with only 1 byte left
+  if (uint8_t(input[length - 3]) >= 0xf0) {
+    return length - 3;
+  } // 4-byte characters with only 3 bytes left
+  return length;
+}
+
+} // namespace utf8
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8.h */
+/* begin file include/simdutf/scalar/utf8_to_latin1/utf8_to_latin1.h */
+#ifndef SIMDUTF_UTF8_TO_LATIN1_H
+#define SIMDUTF_UTF8_TO_LATIN1_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8_to_latin1 {
+
+template <typename InputPtr, typename OutputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires(simdutf::detail::indexes_into_byte_like<InputPtr> &&
+           simdutf::detail::indexes_into_byte_like<OutputPtr>)
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   OutputPtr latin_output) {
+  size_t pos = 0;
+  auto start = latin_output;
+
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2}; // We are only interested in these bits: 1000 1000
+                             // 1000 1000 .... etc
+        if ((v & 0x8080808080808080) ==
+            0) { // if NONE of these are set, e.g. all of them are zero, then
+                 // everything is ASCII
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *latin_output++ = char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    // suppose it is not an all ASCII byte sequence
+    uint8_t leading_byte = data[pos]; // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *latin_output++ = char(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) ==
+               0b11000000) { // the first three bits indicate:
+      // We have a two-byte UTF-8
+      if (pos + 1 >= len) {
+        return 0;
+      } // minimal bound checking
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return 0;
+      } // checks if the next byte is a valid continuation byte in UTF-8. A
+        // valid continuation byte starts with 10.
+      // range check -
+      uint32_t code_point =
+          (leading_byte & 0b00011111) << 6 |
+          (data[pos + 1] &
+           0b00111111); // assembles the Unicode code point from the two bytes.
+                        // It does this by discarding the leading 110 and 10
+                        // bits from the two bytes, shifting the remaining bits
+                        // of the first byte, and then combining the results
+                        // with a bitwise OR operation.
+      if (code_point < 0x80 || 0xFF < code_point) {
+        return 0; // We only care about the range 129-255 which is Non-ASCII
+                  // latin1 characters. A code_point beneath 0x80 is invalid as
+                  // it is already covered by bytes whose leading bit is zero.
+      }
+      *latin_output++ = char(code_point);
+      pos += 2;
+    } else {
+      return 0;
+    }
+  }
+  return latin_output - start;
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 result convert_with_errors(InputPtr data, size_t len,
+                                               char *latin_output) {
+  size_t pos = 0;
+  char *start{latin_output};
+
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2}; // We are only interested in these bits: 1000 1000
+                             // 1000 1000...etc
+        if ((v & 0x8080808080808080) ==
+            0) { // if NONE of these are set, e.g. all of them are zero, then
+                 // everything is ASCII
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *latin_output++ = char(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+    // suppose it is not an all ASCII byte sequence
+    uint8_t leading_byte = data[pos]; // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *latin_output++ = char(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) ==
+               0b11000000) { // the first three bits indicate:
+      // We have a two-byte UTF-8
+      if (pos + 1 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      } // checks if the next byte is a valid continuation byte in UTF-8. A
+        // valid continuation byte starts with 10.
+      // range check -
+      uint32_t code_point =
+          (leading_byte & 0b00011111) << 6 |
+          (data[pos + 1] &
+           0b00111111); // assembles the Unicode code point from the two bytes.
+                        // It does this by discarding the leading 110 and 10
+                        // bits from the two bytes, shifting the remaining bits
+                        // of the first byte, and then combining the results
+                        // with a bitwise OR operation.
+      if (code_point < 0x80) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0xFF < code_point) {
+        return result(error_code::TOO_LARGE, pos);
+      } // We only care about the range 129-255 which is Non-ASCII latin1
+        // characters
+      *latin_output++ = char(code_point);
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8
+      return result(error_code::TOO_LARGE, pos);
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      return result(error_code::TOO_LARGE, pos);
+    } else {
+      // we either have too many continuation bytes or an invalid leading byte
+      if ((leading_byte & 0b11000000) == 0b10000000) {
+        return result(error_code::TOO_LONG, pos);
+      }
+
+      return result(error_code::HEADER_BITS, pos);
+    }
+  }
+  return result(error_code::SUCCESS, latin_output - start);
+}
+
+inline result rewind_and_convert_with_errors(size_t prior_bytes,
+                                             const char *buf, size_t len,
+                                             char *latin1_output) {
+  size_t extra_len{0};
+  // We potentially need to go back in time and find a leading byte.
+  // In theory '3' would be sufficient, but sometimes the error can go back
+  // quite far.
+  size_t how_far_back = prior_bytes;
+  // size_t how_far_back = 3; // 3 bytes in the past + current position
+  // if(how_far_back >= prior_bytes) { how_far_back = prior_bytes; }
+  bool found_leading_bytes{false};
+  // important: it is i <= how_far_back and not 'i < how_far_back'.
+  for (size_t i = 0; i <= how_far_back; i++) {
+    unsigned char byte = buf[-static_cast<std::ptrdiff_t>(i)];
+    found_leading_bytes = ((byte & 0b11000000) != 0b10000000);
+    if (found_leading_bytes) {
+      if (i > 0 && byte < 128) {
+        // If we had to go back and the leading byte is ascii
+        // then we can stop right away.
+        return result(error_code::TOO_LONG, 0 - i + 1);
+      }
+      buf -= i;
+      extra_len = i;
+      break;
+    }
+  }
+  //
+  // It is possible for this function to return a negative count in its result.
+  // C++ Standard Section 18.1 defines size_t is in <cstddef> which is described
+  // in C Standard as <stddef.h>. C Standard Section 4.1.5 defines size_t as an
+  // unsigned integral type of the result of the sizeof operator
+  //
+  // An unsigned type will simply wrap round arithmetically (well defined).
+  //
+  if (!found_leading_bytes) {
+    // If how_far_back == 3, we may have four consecutive continuation bytes!!!
+    // [....] [continuation] [continuation] [continuation] | [buf is
+    // continuation] Or we possibly have a stream that does not start with a
+    // leading byte.
+    return result(error_code::TOO_LONG, 0 - how_far_back);
+  }
+  result res = convert_with_errors(buf, len + extra_len, latin1_output);
+  if (res.error) {
+    res.count -= extra_len;
+  }
+  return res;
+}
+
+} // namespace utf8_to_latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8_to_latin1/utf8_to_latin1.h */
+/* begin file include/simdutf/scalar/utf8_to_latin1/valid_utf8_to_latin1.h */
+#ifndef SIMDUTF_VALID_UTF8_TO_LATIN1_H
+#define SIMDUTF_VALID_UTF8_TO_LATIN1_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8_to_latin1 {
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert_valid(InputPtr data, size_t len,
+                                         char *latin_output) {
+
+  size_t pos = 0;
+  char *start{latin_output};
+
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 |
+                   v2}; // We are only interested in these bits: 1000 1000 1000
+                        // 1000, so it makes sense to concatenate everything
+        if ((v & 0x8080808080808080) ==
+            0) { // if NONE of these are set, e.g. all of them are zero, then
+                 // everything is ASCII
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *latin_output++ = uint8_t(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    // suppose it is not an all ASCII byte sequence
+    auto leading_byte = uint8_t(data[pos]); // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *latin_output++ = char(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) ==
+               0b11000000) { // the first three bits indicate:
+      // We have a two-byte UTF-8
+      if (pos + 1 >= len) {
+        break;
+      } // minimal bound checking
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return 0;
+      } // checks if the next byte is a valid continuation byte in UTF-8. A
+        // valid continuation byte starts with 10.
+      // range check -
+      uint32_t code_point =
+          (leading_byte & 0b00011111) << 6 |
+          (uint8_t(data[pos + 1]) &
+           0b00111111); // assembles the Unicode code point from the two bytes.
+                        // It does this by discarding the leading 110 and 10
+                        // bits from the two bytes, shifting the remaining bits
+                        // of the first byte, and then combining the results
+                        // with a bitwise OR operation.
+      *latin_output++ = char(code_point);
+      pos += 2;
+    } else {
+      // we may have a continuation but we do not do error checking
+      return 0;
+    }
+  }
+  return latin_output - start;
+}
+
+} // namespace utf8_to_latin1
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8_to_latin1/valid_utf8_to_latin1.h */
+/* begin file include/simdutf/scalar/utf8_to_utf16/utf8_to_utf16.h */
+#ifndef SIMDUTF_UTF8_TO_UTF16_H
+#define SIMDUTF_UTF8_TO_UTF16_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8_to_utf16 {
+
+template <endianness big_endian, typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    // try to convert the next block of 16 ASCII bytes
+    {
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2};
+        if ((v & 0x8080808080808080) == 0) {
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *utf16_output++ = !match_system(big_endian)
+                                  ? char16_t(u16_swap_bytes(data[pos]))
+                                  : char16_t(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    uint8_t leading_byte = data[pos]; // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *utf16_output++ = !match_system(big_endian)
+                            ? char16_t(u16_swap_bytes(leading_byte))
+                            : char16_t(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      // We have a two-byte UTF-8, it should become
+      // a single UTF-16 word.
+      if (pos + 1 >= len) {
+        return 0;
+      } // minimal bound checking
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      // range check
+      uint32_t code_point =
+          (leading_byte & 0b00011111) << 6 | (data[pos + 1] & 0b00111111);
+      if (code_point < 0x80 || 0x7ff < code_point) {
+        return 0;
+      }
+      if constexpr (!match_system(big_endian)) {
+        code_point = uint32_t(u16_swap_bytes(uint16_t(code_point)));
+      }
+      *utf16_output++ = char16_t(code_point);
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8, it should become
+      // a single UTF-16 word.
+      if (pos + 2 >= len) {
+        return 0;
+      } // minimal bound checking
+
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00001111) << 12 |
+                            (data[pos + 1] & 0b00111111) << 6 |
+                            (data[pos + 2] & 0b00111111);
+      if (code_point < 0x800 || 0xffff < code_point ||
+          (0xd7ff < code_point && code_point < 0xe000)) {
+        return 0;
+      }
+      if constexpr (!match_system(big_endian)) {
+        code_point = uint32_t(u16_swap_bytes(uint16_t(code_point)));
+      }
+      *utf16_output++ = char16_t(code_point);
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      if (pos + 3 >= len) {
+        return 0;
+      } // minimal bound checking
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      if ((data[pos + 2] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      if ((data[pos + 3] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+
+      // range check
+      uint32_t code_point = (leading_byte & 0b00000111) << 18 |
+                            (data[pos + 1] & 0b00111111) << 12 |
+                            (data[pos + 2] & 0b00111111) << 6 |
+                            (data[pos + 3] & 0b00111111);
+      if (code_point <= 0xffff || 0x10ffff < code_point) {
+        return 0;
+      }
+      code_point -= 0x10000;
+      uint16_t high_surrogate = uint16_t(0xD800 + (code_point >> 10));
+      uint16_t low_surrogate = uint16_t(0xDC00 + (code_point & 0x3FF));
+      if constexpr (!match_system(big_endian)) {
+        high_surrogate = u16_swap_bytes(high_surrogate);
+        low_surrogate = u16_swap_bytes(low_surrogate);
+      }
+      *utf16_output++ = char16_t(high_surrogate);
+      *utf16_output++ = char16_t(low_surrogate);
+      pos += 4;
+    } else {
+      return 0;
+    }
+  }
+  return utf16_output - start;
+}
+
+template <endianness big_endian, typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 result convert_with_errors(InputPtr data, size_t len,
+                                               char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2};
+        if ((v & 0x8080808080808080) == 0) {
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            const char16_t byte = uint8_t(data[pos]);
+            *utf16_output++ =
+                !match_system(big_endian) ? u16_swap_bytes(byte) : byte;
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    auto leading_byte = uint8_t(data[pos]); // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *utf16_output++ = !match_system(big_endian)
+                            ? char16_t(u16_swap_bytes(leading_byte))
+                            : char16_t(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      // We have a two-byte UTF-8, it should become
+      // a single UTF-16 word.
+      if (pos + 1 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00011111) << 6 |
+                            (uint8_t(data[pos + 1]) & 0b00111111);
+      if (code_point < 0x80 || 0x7ff < code_point) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if constexpr (!match_system(big_endian)) {
+        code_point = uint32_t(u16_swap_bytes(uint16_t(code_point)));
+      }
+      *utf16_output++ = char16_t(code_point);
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8, it should become
+      // a single UTF-16 word.
+      if (pos + 2 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((uint8_t(data[pos + 2]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00001111) << 12 |
+                            (uint8_t(data[pos + 1]) & 0b00111111) << 6 |
+                            (uint8_t(data[pos + 2]) & 0b00111111);
+      if ((code_point < 0x800) || (0xffff < code_point)) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0xd7ff < code_point && code_point < 0xe000) {
+        return result(error_code::SURROGATE, pos);
+      }
+      if constexpr (!match_system(big_endian)) {
+        code_point = uint32_t(u16_swap_bytes(uint16_t(code_point)));
+      }
+      *utf16_output++ = char16_t(code_point);
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      if (pos + 3 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((uint8_t(data[pos + 2]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((uint8_t(data[pos + 3]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+
+      // range check
+      uint32_t code_point = (leading_byte & 0b00000111) << 18 |
+                            (uint8_t(data[pos + 1]) & 0b00111111) << 12 |
+                            (uint8_t(data[pos + 2]) & 0b00111111) << 6 |
+                            (uint8_t(data[pos + 3]) & 0b00111111);
+      if (code_point <= 0xffff) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0x10ffff < code_point) {
+        return result(error_code::TOO_LARGE, pos);
+      }
+      code_point -= 0x10000;
+      uint16_t high_surrogate = uint16_t(0xD800 + (code_point >> 10));
+      uint16_t low_surrogate = uint16_t(0xDC00 + (code_point & 0x3FF));
+      if constexpr (!match_system(big_endian)) {
+        high_surrogate = u16_swap_bytes(high_surrogate);
+        low_surrogate = u16_swap_bytes(low_surrogate);
+      }
+      *utf16_output++ = char16_t(high_surrogate);
+      *utf16_output++ = char16_t(low_surrogate);
+      pos += 4;
+    } else {
+      // we either have too many continuation bytes or an invalid leading byte
+      if ((leading_byte & 0b11000000) == 0b10000000) {
+        return result(error_code::TOO_LONG, pos);
+      } else {
+        return result(error_code::HEADER_BITS, pos);
+      }
+    }
+  }
+  return result(error_code::SUCCESS, utf16_output - start);
+}
+
+/**
+ * When rewind_and_convert_with_errors is called, we are pointing at 'buf' and
+ * we have up to len input bytes left, and we encountered some error. It is
+ * possible that the error is at 'buf' exactly, but it could also be in the
+ * previous bytes  (up to 3 bytes back).
+ *
+ * prior_bytes indicates how many bytes, prior to 'buf' may belong to the
+ * current memory section and can be safely accessed. We prior_bytes to access
+ * safely up to three bytes before 'buf'.
+ *
+ * The caller is responsible to ensure that len > 0.
+ *
+ * If the error is believed to have occurred prior to 'buf', the count value
+ * contain in the result will be SIZE_T - 1, SIZE_T - 2, or SIZE_T - 3.
+ */
+template <endianness endian>
+inline result rewind_and_convert_with_errors(size_t prior_bytes,
+                                             const char *buf, size_t len,
+                                             char16_t *utf16_output) {
+  size_t extra_len{0};
+  // We potentially need to go back in time and find a leading byte.
+  // In theory '3' would be sufficient, but sometimes the error can go back
+  // quite far.
+  size_t how_far_back = prior_bytes;
+  // size_t how_far_back = 3; // 3 bytes in the past + current position
+  // if(how_far_back >= prior_bytes) { how_far_back = prior_bytes; }
+  bool found_leading_bytes{false};
+  // important: it is i <= how_far_back and not 'i < how_far_back'.
+  for (size_t i = 0; i <= how_far_back; i++) {
+    unsigned char byte = buf[-static_cast<std::ptrdiff_t>(i)];
+    found_leading_bytes = ((byte & 0b11000000) != 0b10000000);
+    if (found_leading_bytes) {
+      if (i > 0 && byte < 128) {
+        // If we had to go back and the leading byte is ascii
+        // then we can stop right away.
+        return result(error_code::TOO_LONG, 0 - i + 1);
+      }
+      buf -= i;
+      extra_len = i;
+      break;
+    }
+  }
+  //
+  // It is possible for this function to return a negative count in its result.
+  // C++ Standard Section 18.1 defines size_t is in <cstddef> which is described
+  // in C Standard as <stddef.h>. C Standard Section 4.1.5 defines size_t as an
+  // unsigned integral type of the result of the sizeof operator
+  //
+  // An unsigned type will simply wrap round arithmetically (well defined).
+  //
+  if (!found_leading_bytes) {
+    // If how_far_back == 3, we may have four consecutive continuation bytes!!!
+    // [....] [continuation] [continuation] [continuation] | [buf is
+    // continuation] Or we possibly have a stream that does not start with a
+    // leading byte.
+    return result(error_code::TOO_LONG, 0 - how_far_back);
+  }
+  result res = convert_with_errors<endian>(buf, len + extra_len, utf16_output);
+  if (res.error) {
+    res.count -= extra_len;
+  }
+  return res;
+}
+
+} // namespace utf8_to_utf16
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8_to_utf16/utf8_to_utf16.h */
+/* begin file include/simdutf/scalar/utf8_to_utf16/valid_utf8_to_utf16.h */
+#ifndef SIMDUTF_VALID_UTF8_TO_UTF16_H
+#define SIMDUTF_VALID_UTF8_TO_UTF16_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8_to_utf16 {
+
+template <endianness big_endian, typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert_valid(InputPtr data, size_t len,
+                                         char16_t *utf16_output) {
+  size_t pos = 0;
+  char16_t *start{utf16_output};
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {                       // try to convert the next block of 8 ASCII bytes
+      if (pos + 8 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0x8080808080808080) == 0) {
+          size_t final_pos = pos + 8;
+          while (pos < final_pos) {
+            const char16_t byte = uint8_t(data[pos]);
+            *utf16_output++ =
+                !match_system(big_endian) ? u16_swap_bytes(byte) : byte;
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+
+    auto leading_byte = uint8_t(data[pos]); // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *utf16_output++ = !match_system(big_endian)
+                            ? char16_t(u16_swap_bytes(leading_byte))
+                            : char16_t(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      // We have a two-byte UTF-8, it should become
+      // a single UTF-16 word.
+      if (pos + 1 >= len) {
+        break;
+      } // minimal bound checking
+      uint16_t code_point = uint16_t(((leading_byte & 0b00011111) << 6) |
+                                     (uint8_t(data[pos + 1]) & 0b00111111));
+      if constexpr (!match_system(big_endian)) {
+        code_point = u16_swap_bytes(uint16_t(code_point));
+      }
+      *utf16_output++ = char16_t(code_point);
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8, it should become
+      // a single UTF-16 word.
+      if (pos + 2 >= len) {
+        break;
+      } // minimal bound checking
+      uint16_t code_point =
+          uint16_t(((leading_byte & 0b00001111) << 12) |
+                   ((uint8_t(data[pos + 1]) & 0b00111111) << 6) |
+                   (uint8_t(data[pos + 2]) & 0b00111111));
+      if constexpr (!match_system(big_endian)) {
+        code_point = u16_swap_bytes(uint16_t(code_point));
+      }
+      *utf16_output++ = char16_t(code_point);
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      if (pos + 3 >= len) {
+        break;
+      } // minimal bound checking
+      uint32_t code_point = ((leading_byte & 0b00000111) << 18) |
+                            ((uint8_t(data[pos + 1]) & 0b00111111) << 12) |
+                            ((uint8_t(data[pos + 2]) & 0b00111111) << 6) |
+                            (uint8_t(data[pos + 3]) & 0b00111111);
+      code_point -= 0x10000;
+      uint16_t high_surrogate = uint16_t(0xD800 + (code_point >> 10));
+      uint16_t low_surrogate = uint16_t(0xDC00 + (code_point & 0x3FF));
+      if constexpr (!match_system(big_endian)) {
+        high_surrogate = u16_swap_bytes(high_surrogate);
+        low_surrogate = u16_swap_bytes(low_surrogate);
+      }
+      *utf16_output++ = char16_t(high_surrogate);
+      *utf16_output++ = char16_t(low_surrogate);
+      pos += 4;
+    } else {
+      // we may have a continuation but we do not do error checking
+      return 0;
+    }
+  }
+  return utf16_output - start;
+}
+
+} // namespace utf8_to_utf16
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8_to_utf16/valid_utf8_to_utf16.h */
+/* begin file include/simdutf/scalar/utf8_to_utf32/utf8_to_utf32.h */
+#ifndef SIMDUTF_UTF8_TO_UTF32_H
+#define SIMDUTF_UTF8_TO_UTF32_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8_to_utf32 {
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert(InputPtr data, size_t len,
+                                   char32_t *utf32_output) {
+  size_t pos = 0;
+  char32_t *start{utf32_output};
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2};
+        if ((v & 0x8080808080808080) == 0) {
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *utf32_output++ = uint8_t(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+    auto leading_byte = uint8_t(data[pos]); // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *utf32_output++ = char32_t(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      // We have a two-byte UTF-8
+      if (pos + 1 >= len) {
+        return 0;
+      } // minimal bound checking
+      if ((data[pos + 1] & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00011111) << 6 |
+                            (uint8_t(data[pos + 1]) & 0b00111111);
+      if (code_point < 0x80 || 0x7ff < code_point) {
+        return 0;
+      }
+      *utf32_output++ = char32_t(code_point);
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8
+      if (pos + 2 >= len) {
+        return 0;
+      } // minimal bound checking
+
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      if ((uint8_t(data[pos + 2]) & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00001111) << 12 |
+                            (uint8_t(data[pos + 1]) & 0b00111111) << 6 |
+                            (uint8_t(data[pos + 2]) & 0b00111111);
+      if (code_point < 0x800 || 0xffff < code_point ||
+          (0xd7ff < code_point && code_point < 0xe000)) {
+        return 0;
+      }
+      *utf32_output++ = char32_t(code_point);
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      if (pos + 3 >= len) {
+        return 0;
+      } // minimal bound checking
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      if ((uint8_t(data[pos + 2]) & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+      if ((uint8_t(data[pos + 3]) & 0b11000000) != 0b10000000) {
+        return 0;
+      }
+
+      // range check
+      uint32_t code_point = (leading_byte & 0b00000111) << 18 |
+                            (uint8_t(data[pos + 1]) & 0b00111111) << 12 |
+                            (uint8_t(data[pos + 2]) & 0b00111111) << 6 |
+                            (uint8_t(data[pos + 3]) & 0b00111111);
+      if (code_point <= 0xffff || 0x10ffff < code_point) {
+        return 0;
+      }
+      *utf32_output++ = char32_t(code_point);
+      pos += 4;
+    } else {
+      return 0;
+    }
+  }
+  return utf32_output - start;
+}
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 result convert_with_errors(InputPtr data, size_t len,
+                                               char32_t *utf32_output) {
+  size_t pos = 0;
+  char32_t *start{utf32_output};
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 16 ASCII bytes
+      if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that
+                             // they are ascii
+        uint64_t v1;
+        ::memcpy(&v1, data + pos, sizeof(uint64_t));
+        uint64_t v2;
+        ::memcpy(&v2, data + pos + sizeof(uint64_t), sizeof(uint64_t));
+        uint64_t v{v1 | v2};
+        if ((v & 0x8080808080808080) == 0) {
+          size_t final_pos = pos + 16;
+          while (pos < final_pos) {
+            *utf32_output++ = uint8_t(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+    auto leading_byte = uint8_t(data[pos]); // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *utf32_output++ = char32_t(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      // We have a two-byte UTF-8
+      if (pos + 1 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00011111) << 6 |
+                            (uint8_t(data[pos + 1]) & 0b00111111);
+      if (code_point < 0x80 || 0x7ff < code_point) {
+        return result(error_code::OVERLONG, pos);
+      }
+      *utf32_output++ = char32_t(code_point);
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8
+      if (pos + 2 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((uint8_t(data[pos + 2]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      // range check
+      uint32_t code_point = (leading_byte & 0b00001111) << 12 |
+                            (uint8_t(data[pos + 1]) & 0b00111111) << 6 |
+                            (uint8_t(data[pos + 2]) & 0b00111111);
+      if (code_point < 0x800 || 0xffff < code_point) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0xd7ff < code_point && code_point < 0xe000) {
+        return result(error_code::SURROGATE, pos);
+      }
+      *utf32_output++ = char32_t(code_point);
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      if (pos + 3 >= len) {
+        return result(error_code::TOO_SHORT, pos);
+      } // minimal bound checking
+      if ((uint8_t(data[pos + 1]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((uint8_t(data[pos + 2]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+      if ((uint8_t(data[pos + 3]) & 0b11000000) != 0b10000000) {
+        return result(error_code::TOO_SHORT, pos);
+      }
+
+      // range check
+      uint32_t code_point = (leading_byte & 0b00000111) << 18 |
+                            (uint8_t(data[pos + 1]) & 0b00111111) << 12 |
+                            (uint8_t(data[pos + 2]) & 0b00111111) << 6 |
+                            (uint8_t(data[pos + 3]) & 0b00111111);
+      if (code_point <= 0xffff) {
+        return result(error_code::OVERLONG, pos);
+      }
+      if (0x10ffff < code_point) {
+        return result(error_code::TOO_LARGE, pos);
+      }
+      *utf32_output++ = char32_t(code_point);
+      pos += 4;
+    } else {
+      // we either have too many continuation bytes or an invalid leading byte
+      if ((leading_byte & 0b11000000) == 0b10000000) {
+        return result(error_code::TOO_LONG, pos);
+      } else {
+        return result(error_code::HEADER_BITS, pos);
+      }
+    }
+  }
+  return result(error_code::SUCCESS, utf32_output - start);
+}
+
+/**
+ * When rewind_and_convert_with_errors is called, we are pointing at 'buf' and
+ * we have up to len input bytes left, and we encountered some error. It is
+ * possible that the error is at 'buf' exactly, but it could also be in the
+ * previous bytes location (up to 3 bytes back).
+ *
+ * prior_bytes indicates how many bytes, prior to 'buf' may belong to the
+ * current memory section and can be safely accessed. We prior_bytes to access
+ * safely up to three bytes before 'buf'.
+ *
+ * The caller is responsible to ensure that len > 0.
+ *
+ * If the error is believed to have occurred prior to 'buf', the count value
+ * contain in the result will be SIZE_T - 1, SIZE_T - 2, or SIZE_T - 3.
+ */
+inline result rewind_and_convert_with_errors(size_t prior_bytes,
+                                             const char *buf, size_t len,
+                                             char32_t *utf32_output) {
+  size_t extra_len{0};
+  // We potentially need to go back in time and find a leading byte.
+  size_t how_far_back = 3; // 3 bytes in the past + current position
+  if (how_far_back > prior_bytes) {
+    how_far_back = prior_bytes;
+  }
+  bool found_leading_bytes{false};
+  // important: it is i <= how_far_back and not 'i < how_far_back'.
+  for (size_t i = 0; i <= how_far_back; i++) {
+    unsigned char byte = buf[-static_cast<std::ptrdiff_t>(i)];
+    found_leading_bytes = ((byte & 0b11000000) != 0b10000000);
+    if (found_leading_bytes) {
+      if (i > 0 && byte < 128) {
+        // If we had to go back and the leading byte is ascii
+        // then we can stop right away.
+        return result(error_code::TOO_LONG, 0 - i + 1);
+      }
+      buf -= i;
+      extra_len = i;
+      break;
+    }
+  }
+  //
+  // It is possible for this function to return a negative count in its result.
+  // C++ Standard Section 18.1 defines size_t is in <cstddef> which is described
+  // in C Standard as <stddef.h>. C Standard Section 4.1.5 defines size_t as an
+  // unsigned integral type of the result of the sizeof operator
+  //
+  // An unsigned type will simply wrap round arithmetically (well defined).
+  //
+  if (!found_leading_bytes) {
+    // If how_far_back == 3, we may have four consecutive continuation bytes!!!
+    // [....] [continuation] [continuation] [continuation] | [buf is
+    // continuation] Or we possibly have a stream that does not start with a
+    // leading byte.
+    return result(error_code::TOO_LONG, 0 - how_far_back);
+  }
+
+  result res = convert_with_errors(buf, len + extra_len, utf32_output);
+  if (res.error) {
+    res.count -= extra_len;
+  }
+  return res;
+}
+
+} // namespace utf8_to_utf32
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8_to_utf32/utf8_to_utf32.h */
+/* begin file include/simdutf/scalar/utf8_to_utf32/valid_utf8_to_utf32.h */
+#ifndef SIMDUTF_VALID_UTF8_TO_UTF32_H
+#define SIMDUTF_VALID_UTF8_TO_UTF32_H
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace utf8_to_utf32 {
+
+template <typename InputPtr>
+#if SIMDUTF_CPLUSPLUS20
+  requires simdutf::detail::indexes_into_byte_like<InputPtr>
+#endif
+simdutf_constexpr23 size_t convert_valid(InputPtr data, size_t len,
+                                         char32_t *utf32_output) {
+  size_t pos = 0;
+  char32_t *start{utf32_output};
+  while (pos < len) {
+#if SIMDUTF_CPLUSPLUS23
+    if !consteval
+#endif
+    {
+      // try to convert the next block of 8 ASCII bytes
+      if (pos + 8 <= len) { // if it is safe to read 8 more bytes, check that
+                            // they are ascii
+        uint64_t v;
+        ::memcpy(&v, data + pos, sizeof(uint64_t));
+        if ((v & 0x8080808080808080) == 0) {
+          size_t final_pos = pos + 8;
+          while (pos < final_pos) {
+            *utf32_output++ = uint8_t(data[pos]);
+            pos++;
+          }
+          continue;
+        }
+      }
+    }
+    auto leading_byte = uint8_t(data[pos]); // leading byte
+    if (leading_byte < 0b10000000) {
+      // converting one ASCII byte !!!
+      *utf32_output++ = char32_t(leading_byte);
+      pos++;
+    } else if ((leading_byte & 0b11100000) == 0b11000000) {
+      // We have a two-byte UTF-8
+      if (pos + 1 >= len) {
+        break;
+      } // minimal bound checking
+      *utf32_output++ = char32_t(((leading_byte & 0b00011111) << 6) |
+                                 (uint8_t(data[pos + 1]) & 0b00111111));
+      pos += 2;
+    } else if ((leading_byte & 0b11110000) == 0b11100000) {
+      // We have a three-byte UTF-8
+      if (pos + 2 >= len) {
+        break;
+      } // minimal bound checking
+      *utf32_output++ = char32_t(((leading_byte & 0b00001111) << 12) |
+                                 ((uint8_t(data[pos + 1]) & 0b00111111) << 6) |
+                                 (uint8_t(data[pos + 2]) & 0b00111111));
+      pos += 3;
+    } else if ((leading_byte & 0b11111000) == 0b11110000) { // 0b11110000
+      // we have a 4-byte UTF-8 word.
+      if (pos + 3 >= len) {
+        break;
+      } // minimal bound checking
+      uint32_t code_word = ((leading_byte & 0b00000111) << 18) |
+                           ((uint8_t(data[pos + 1]) & 0b00111111) << 12) |
+                           ((uint8_t(data[pos + 2]) & 0b00111111) << 6) |
+                           (uint8_t(data[pos + 3]) & 0b00111111);
+      *utf32_output++ = char32_t(code_word);
+      pos += 4;
+    } else {
+      // we may have a continuation but we do not do error checking
+      return 0;
+    }
+  }
+  return utf32_output - start;
+}
+
+} // namespace utf8_to_utf32
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/utf8_to_utf32/valid_utf8_to_utf32.h */
+
+namespace simdutf {
+
+constexpr size_t default_line_length =
+    76; ///< default line length for base64 encoding with lines
+
+  #ifndef SIMDUTF_NEED_TRAILING_ZEROES
+    #define SIMDUTF_NEED_TRAILING_ZEROES 1
+  #endif
+
+// base64_options are used to specify the base64 encoding options.
+// ASCII spaces are ' ', '\t', '\n', '\r', '\f'
+// garbage characters are characters that are not part of the base64 alphabet
+// nor ASCII spaces.
+constexpr uint64_t base64_reverse_padding =
+    2; /* modifier for base64_default and base64_url */
+enum base64_options : uint64_t {
+  base64_default = 0, /* standard base64 format (with padding) */
+  base64_url = 1,     /* base64url format (no padding) */
+  base64_default_no_padding =
+      base64_default |
+      base64_reverse_padding, /* standard base64 format without padding */
+  base64_url_with_padding =
+      base64_url | base64_reverse_padding, /* base64url with padding */
+  base64_default_accept_garbage =
+      4, /* standard base64 format accepting garbage characters, the input stops
+            with the first '=' if any */
+  base64_url_accept_garbage =
+      5, /* base64url format accepting garbage characters, the input stops with
+            the first '=' if any */
+  base64_default_or_url =
+      8, /* standard/base64url hybrid format (only meaningful for decoding!) */
+  base64_default_or_url_accept_garbage =
+      12, /* standard/base64url hybrid format accepting garbage characters
+             (only meaningful for decoding!), the input stops with the first '='
+             if any */
+};
+
+// last_chunk_handling_options are used to specify the handling of the last
+// chunk in base64 decoding.
+// https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
+enum last_chunk_handling_options : uint64_t {
+  loose = 0,  /* standard base64 format, decode partial final chunk */
+  strict = 1, /* error when the last chunk is partial, 2 or 3 chars, and
+                 unpadded, or non-zero bit padding */
+  stop_before_partial =
+      2, /* if the last chunk is partial, ignore it (no error) */
+  only_full_chunks =
+      3 /* only decode full blocks (4 base64 characters, no padding) */
+};
+
+inline simdutf_constexpr23 bool
+is_partial(last_chunk_handling_options options) {
+  return (options == stop_before_partial) || (options == only_full_chunks);
+}
+
+namespace detail {
+simdutf_warn_unused const char *find(const char *start, const char *end,
+                                     char character) noexcept;
+simdutf_warn_unused const char16_t *
+find(const char16_t *start, const char16_t *end, char16_t character) noexcept;
+} // namespace detail
+
+/**
+ * Find the first occurrence of a character in a string. If the character is
+ * not found, return a pointer to the end of the string.
+ * @param start        the start of the string
+ * @param end          the end of the string
+ * @param character    the character to find
+ * @return a pointer to the first occurrence of the character in the string,
+ * or a pointer to the end of the string if the character is not found.
+ *
+ */
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 const char *
+find(const char *start, const char *end, char character) noexcept {
+  #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    for (; start != end; ++start)
+      if (*start == character)
+        return start;
+    return end;
+  } else
+  #endif
+  {
+    return detail::find(start, end, character);
+  }
+}
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 const char16_t *
+find(const char16_t *start, const char16_t *end, char16_t character) noexcept {
+    // implementation note: this is repeated instead of a template, to ensure
+    // the api is still a function and compiles without concepts
+  #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    for (; start != end; ++start)
+      if (*start == character)
+        return start;
+    return end;
+  } else
+  #endif
+  {
+    return detail::find(start, end, character);
+  }
+}
+}
+  // We include base64_tables once.
+/* begin file include/simdutf/base64_tables.h */
+#ifndef SIMDUTF_BASE64_TABLES_H
+#define SIMDUTF_BASE64_TABLES_H
+#include <cstdint>
+
+namespace simdutf {
+namespace {
+namespace tables {
+namespace base64 {
+namespace base64_default {
+
+constexpr char e0[256] = {
+    'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'D', 'D', 'D',
+    'D', 'E', 'E', 'E', 'E', 'F', 'F', 'F', 'F', 'G', 'G', 'G', 'G', 'H', 'H',
+    'H', 'H', 'I', 'I', 'I', 'I', 'J', 'J', 'J', 'J', 'K', 'K', 'K', 'K', 'L',
+    'L', 'L', 'L', 'M', 'M', 'M', 'M', 'N', 'N', 'N', 'N', 'O', 'O', 'O', 'O',
+    'P', 'P', 'P', 'P', 'Q', 'Q', 'Q', 'Q', 'R', 'R', 'R', 'R', 'S', 'S', 'S',
+    'S', 'T', 'T', 'T', 'T', 'U', 'U', 'U', 'U', 'V', 'V', 'V', 'V', 'W', 'W',
+    'W', 'W', 'X', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'Z', 'a',
+    'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'd', 'd',
+    'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g', 'g', 'h', 'h', 'h',
+    'h', 'i', 'i', 'i', 'i', 'j', 'j', 'j', 'j', 'k', 'k', 'k', 'k', 'l', 'l',
+    'l', 'l', 'm', 'm', 'm', 'm', 'n', 'n', 'n', 'n', 'o', 'o', 'o', 'o', 'p',
+    'p', 'p', 'p', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 's', 's', 's', 's',
+    't', 't', 't', 't', 'u', 'u', 'u', 'u', 'v', 'v', 'v', 'v', 'w', 'w', 'w',
+    'w', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'z', 'z', 'z', 'z', '0', '0',
+    '0', '0', '1', '1', '1', '1', '2', '2', '2', '2', '3', '3', '3', '3', '4',
+    '4', '4', '4', '5', '5', '5', '5', '6', '6', '6', '6', '7', '7', '7', '7',
+    '8', '8', '8', '8', '9', '9', '9', '9', '+', '+', '+', '+', '/', '/', '/',
+    '/'};
+
+constexpr char e1[256] = {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C',
+    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
+    '/'};
+
+constexpr char e2[256] = {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', 'A', 'B', 'C',
+    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
+    '/'};
+
+constexpr uint32_t d0[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x000000f8, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
+    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
+    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
+    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
+    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
+    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
+    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
+    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
+    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
+    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
+    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+
+constexpr uint32_t d1[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x0000e003, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
+    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
+    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
+    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
+    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
+    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
+    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
+    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
+    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
+    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
+    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+
+constexpr uint32_t d2[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x00800f00, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
+    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
+    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
+    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
+    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
+    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
+    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
+    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
+    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
+    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
+    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+
+constexpr uint32_t d3[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x003e0000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
+    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
+    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
+    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
+    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
+    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
+    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
+    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
+    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
+    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
+    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+} // namespace base64_default
+
+namespace base64_url {
+
+constexpr char e0[256] = {
+    'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'D', 'D', 'D',
+    'D', 'E', 'E', 'E', 'E', 'F', 'F', 'F', 'F', 'G', 'G', 'G', 'G', 'H', 'H',
+    'H', 'H', 'I', 'I', 'I', 'I', 'J', 'J', 'J', 'J', 'K', 'K', 'K', 'K', 'L',
+    'L', 'L', 'L', 'M', 'M', 'M', 'M', 'N', 'N', 'N', 'N', 'O', 'O', 'O', 'O',
+    'P', 'P', 'P', 'P', 'Q', 'Q', 'Q', 'Q', 'R', 'R', 'R', 'R', 'S', 'S', 'S',
+    'S', 'T', 'T', 'T', 'T', 'U', 'U', 'U', 'U', 'V', 'V', 'V', 'V', 'W', 'W',
+    'W', 'W', 'X', 'X', 'X', 'X', 'Y', 'Y', 'Y', 'Y', 'Z', 'Z', 'Z', 'Z', 'a',
+    'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'd', 'd',
+    'e', 'e', 'e', 'e', 'f', 'f', 'f', 'f', 'g', 'g', 'g', 'g', 'h', 'h', 'h',
+    'h', 'i', 'i', 'i', 'i', 'j', 'j', 'j', 'j', 'k', 'k', 'k', 'k', 'l', 'l',
+    'l', 'l', 'm', 'm', 'm', 'm', 'n', 'n', 'n', 'n', 'o', 'o', 'o', 'o', 'p',
+    'p', 'p', 'p', 'q', 'q', 'q', 'q', 'r', 'r', 'r', 'r', 's', 's', 's', 's',
+    't', 't', 't', 't', 'u', 'u', 'u', 'u', 'v', 'v', 'v', 'v', 'w', 'w', 'w',
+    'w', 'x', 'x', 'x', 'x', 'y', 'y', 'y', 'y', 'z', 'z', 'z', 'z', '0', '0',
+    '0', '0', '1', '1', '1', '1', '2', '2', '2', '2', '3', '3', '3', '3', '4',
+    '4', '4', '4', '5', '5', '5', '5', '6', '6', '6', '6', '7', '7', '7', '7',
+    '8', '8', '8', '8', '9', '9', '9', '9', '-', '-', '-', '-', '_', '_', '_',
+    '_'};
+
+constexpr char e1[256] = {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C',
+    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-',
+    '_'};
+
+constexpr char e2[256] = {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+    'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+    't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
+    'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+    'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
+    'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_', 'A', 'B', 'C',
+    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
+    'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+    'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+    'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-',
+    '_'};
+
+constexpr uint32_t d0[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000f8, 0x01ffffff, 0x01ffffff,
+    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
+    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
+    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
+    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
+    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
+    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
+    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
+    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
+    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
+    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
+    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+constexpr uint32_t d1[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000e003, 0x01ffffff, 0x01ffffff,
+    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
+    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
+    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
+    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
+    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
+    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
+    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
+    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
+    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
+    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
+    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+constexpr uint32_t d2[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00800f00, 0x01ffffff, 0x01ffffff,
+    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
+    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
+    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
+    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
+    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
+    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
+    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
+    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
+    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
+    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
+    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+constexpr uint32_t d3[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003e0000, 0x01ffffff, 0x01ffffff,
+    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
+    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
+    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
+    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
+    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
+    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
+    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
+    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
+    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
+    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
+    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+} // namespace base64_url
+
+namespace base64_default_or_url {
+constexpr uint32_t d0[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x000000f8, 0x01ffffff, 0x000000f8, 0x01ffffff, 0x000000fc,
+    0x000000d0, 0x000000d4, 0x000000d8, 0x000000dc, 0x000000e0, 0x000000e4,
+    0x000000e8, 0x000000ec, 0x000000f0, 0x000000f4, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00000004, 0x00000008, 0x0000000c, 0x00000010, 0x00000014, 0x00000018,
+    0x0000001c, 0x00000020, 0x00000024, 0x00000028, 0x0000002c, 0x00000030,
+    0x00000034, 0x00000038, 0x0000003c, 0x00000040, 0x00000044, 0x00000048,
+    0x0000004c, 0x00000050, 0x00000054, 0x00000058, 0x0000005c, 0x00000060,
+    0x00000064, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x000000fc,
+    0x01ffffff, 0x00000068, 0x0000006c, 0x00000070, 0x00000074, 0x00000078,
+    0x0000007c, 0x00000080, 0x00000084, 0x00000088, 0x0000008c, 0x00000090,
+    0x00000094, 0x00000098, 0x0000009c, 0x000000a0, 0x000000a4, 0x000000a8,
+    0x000000ac, 0x000000b0, 0x000000b4, 0x000000b8, 0x000000bc, 0x000000c0,
+    0x000000c4, 0x000000c8, 0x000000cc, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+constexpr uint32_t d1[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x0000e003, 0x01ffffff, 0x0000e003, 0x01ffffff, 0x0000f003,
+    0x00004003, 0x00005003, 0x00006003, 0x00007003, 0x00008003, 0x00009003,
+    0x0000a003, 0x0000b003, 0x0000c003, 0x0000d003, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00001000, 0x00002000, 0x00003000, 0x00004000, 0x00005000, 0x00006000,
+    0x00007000, 0x00008000, 0x00009000, 0x0000a000, 0x0000b000, 0x0000c000,
+    0x0000d000, 0x0000e000, 0x0000f000, 0x00000001, 0x00001001, 0x00002001,
+    0x00003001, 0x00004001, 0x00005001, 0x00006001, 0x00007001, 0x00008001,
+    0x00009001, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x0000f003,
+    0x01ffffff, 0x0000a001, 0x0000b001, 0x0000c001, 0x0000d001, 0x0000e001,
+    0x0000f001, 0x00000002, 0x00001002, 0x00002002, 0x00003002, 0x00004002,
+    0x00005002, 0x00006002, 0x00007002, 0x00008002, 0x00009002, 0x0000a002,
+    0x0000b002, 0x0000c002, 0x0000d002, 0x0000e002, 0x0000f002, 0x00000003,
+    0x00001003, 0x00002003, 0x00003003, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+constexpr uint32_t d2[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x00800f00, 0x01ffffff, 0x00800f00, 0x01ffffff, 0x00c00f00,
+    0x00000d00, 0x00400d00, 0x00800d00, 0x00c00d00, 0x00000e00, 0x00400e00,
+    0x00800e00, 0x00c00e00, 0x00000f00, 0x00400f00, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00400000, 0x00800000, 0x00c00000, 0x00000100, 0x00400100, 0x00800100,
+    0x00c00100, 0x00000200, 0x00400200, 0x00800200, 0x00c00200, 0x00000300,
+    0x00400300, 0x00800300, 0x00c00300, 0x00000400, 0x00400400, 0x00800400,
+    0x00c00400, 0x00000500, 0x00400500, 0x00800500, 0x00c00500, 0x00000600,
+    0x00400600, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00c00f00,
+    0x01ffffff, 0x00800600, 0x00c00600, 0x00000700, 0x00400700, 0x00800700,
+    0x00c00700, 0x00000800, 0x00400800, 0x00800800, 0x00c00800, 0x00000900,
+    0x00400900, 0x00800900, 0x00c00900, 0x00000a00, 0x00400a00, 0x00800a00,
+    0x00c00a00, 0x00000b00, 0x00400b00, 0x00800b00, 0x00c00b00, 0x00000c00,
+    0x00400c00, 0x00800c00, 0x00c00c00, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+constexpr uint32_t d3[256] = {
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x003e0000, 0x01ffffff, 0x003e0000, 0x01ffffff, 0x003f0000,
+    0x00340000, 0x00350000, 0x00360000, 0x00370000, 0x00380000, 0x00390000,
+    0x003a0000, 0x003b0000, 0x003c0000, 0x003d0000, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x00000000,
+    0x00010000, 0x00020000, 0x00030000, 0x00040000, 0x00050000, 0x00060000,
+    0x00070000, 0x00080000, 0x00090000, 0x000a0000, 0x000b0000, 0x000c0000,
+    0x000d0000, 0x000e0000, 0x000f0000, 0x00100000, 0x00110000, 0x00120000,
+    0x00130000, 0x00140000, 0x00150000, 0x00160000, 0x00170000, 0x00180000,
+    0x00190000, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x003f0000,
+    0x01ffffff, 0x001a0000, 0x001b0000, 0x001c0000, 0x001d0000, 0x001e0000,
+    0x001f0000, 0x00200000, 0x00210000, 0x00220000, 0x00230000, 0x00240000,
+    0x00250000, 0x00260000, 0x00270000, 0x00280000, 0x00290000, 0x002a0000,
+    0x002b0000, 0x002c0000, 0x002d0000, 0x002e0000, 0x002f0000, 0x00300000,
+    0x00310000, 0x00320000, 0x00330000, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff,
+    0x01ffffff, 0x01ffffff, 0x01ffffff, 0x01ffffff};
+} // namespace base64_default_or_url
+constexpr uint64_t thintable_epi8[256] = {
+    0x0706050403020100, 0x0007060504030201, 0x0007060504030200,
+    0x0000070605040302, 0x0007060504030100, 0x0000070605040301,
+    0x0000070605040300, 0x0000000706050403, 0x0007060504020100,
+    0x0000070605040201, 0x0000070605040200, 0x0000000706050402,
+    0x0000070605040100, 0x0000000706050401, 0x0000000706050400,
+    0x0000000007060504, 0x0007060503020100, 0x0000070605030201,
+    0x0000070605030200, 0x0000000706050302, 0x0000070605030100,
+    0x0000000706050301, 0x0000000706050300, 0x0000000007060503,
+    0x0000070605020100, 0x0000000706050201, 0x0000000706050200,
+    0x0000000007060502, 0x0000000706050100, 0x0000000007060501,
+    0x0000000007060500, 0x0000000000070605, 0x0007060403020100,
+    0x0000070604030201, 0x0000070604030200, 0x0000000706040302,
+    0x0000070604030100, 0x0000000706040301, 0x0000000706040300,
+    0x0000000007060403, 0x0000070604020100, 0x0000000706040201,
+    0x0000000706040200, 0x0000000007060402, 0x0000000706040100,
+    0x0000000007060401, 0x0000000007060400, 0x0000000000070604,
+    0x0000070603020100, 0x0000000706030201, 0x0000000706030200,
+    0x0000000007060302, 0x0000000706030100, 0x0000000007060301,
+    0x0000000007060300, 0x0000000000070603, 0x0000000706020100,
+    0x0000000007060201, 0x0000000007060200, 0x0000000000070602,
+    0x0000000007060100, 0x0000000000070601, 0x0000000000070600,
+    0x0000000000000706, 0x0007050403020100, 0x0000070504030201,
+    0x0000070504030200, 0x0000000705040302, 0x0000070504030100,
+    0x0000000705040301, 0x0000000705040300, 0x0000000007050403,
+    0x0000070504020100, 0x0000000705040201, 0x0000000705040200,
+    0x0000000007050402, 0x0000000705040100, 0x0000000007050401,
+    0x0000000007050400, 0x0000000000070504, 0x0000070503020100,
+    0x0000000705030201, 0x0000000705030200, 0x0000000007050302,
+    0x0000000705030100, 0x0000000007050301, 0x0000000007050300,
+    0x0000000000070503, 0x0000000705020100, 0x0000000007050201,
+    0x0000000007050200, 0x0000000000070502, 0x0000000007050100,
+    0x0000000000070501, 0x0000000000070500, 0x0000000000000705,
+    0x0000070403020100, 0x0000000704030201, 0x0000000704030200,
+    0x0000000007040302, 0x0000000704030100, 0x0000000007040301,
+    0x0000000007040300, 0x0000000000070403, 0x0000000704020100,
+    0x0000000007040201, 0x0000000007040200, 0x0000000000070402,
+    0x0000000007040100, 0x0000000000070401, 0x0000000000070400,
+    0x0000000000000704, 0x0000000703020100, 0x0000000007030201,
+    0x0000000007030200, 0x0000000000070302, 0x0000000007030100,
+    0x0000000000070301, 0x0000000000070300, 0x0000000000000703,
+    0x0000000007020100, 0x0000000000070201, 0x0000000000070200,
+    0x0000000000000702, 0x0000000000070100, 0x0000000000000701,
+    0x0000000000000700, 0x0000000000000007, 0x0006050403020100,
+    0x0000060504030201, 0x0000060504030200, 0x0000000605040302,
+    0x0000060504030100, 0x0000000605040301, 0x0000000605040300,
+    0x0000000006050403, 0x0000060504020100, 0x0000000605040201,
+    0x0000000605040200, 0x0000000006050402, 0x0000000605040100,
+    0x0000000006050401, 0x0000000006050400, 0x0000000000060504,
+    0x0000060503020100, 0x0000000605030201, 0x0000000605030200,
+    0x0000000006050302, 0x0000000605030100, 0x0000000006050301,
+    0x0000000006050300, 0x0000000000060503, 0x0000000605020100,
+    0x0000000006050201, 0x0000000006050200, 0x0000000000060502,
+    0x0000000006050100, 0x0000000000060501, 0x0000000000060500,
+    0x0000000000000605, 0x0000060403020100, 0x0000000604030201,
+    0x0000000604030200, 0x0000000006040302, 0x0000000604030100,
+    0x0000000006040301, 0x0000000006040300, 0x0000000000060403,
+    0x0000000604020100, 0x0000000006040201, 0x0000000006040200,
+    0x0000000000060402, 0x0000000006040100, 0x0000000000060401,
+    0x0000000000060400, 0x0000000000000604, 0x0000000603020100,
+    0x0000000006030201, 0x0000000006030200, 0x0000000000060302,
+    0x0000000006030100, 0x0000000000060301, 0x0000000000060300,
+    0x0000000000000603, 0x0000000006020100, 0x0000000000060201,
+    0x0000000000060200, 0x0000000000000602, 0x0000000000060100,
+    0x0000000000000601, 0x0000000000000600, 0x0000000000000006,
+    0x0000050403020100, 0x0000000504030201, 0x0000000504030200,
+    0x0000000005040302, 0x0000000504030100, 0x0000000005040301,
+    0x0000000005040300, 0x0000000000050403, 0x0000000504020100,
+    0x0000000005040201, 0x0000000005040200, 0x0000000000050402,
+    0x0000000005040100, 0x0000000000050401, 0x0000000000050400,
+    0x0000000000000504, 0x0000000503020100, 0x0000000005030201,
+    0x0000000005030200, 0x0000000000050302, 0x0000000005030100,
+    0x0000000000050301, 0x0000000000050300, 0x0000000000000503,
+    0x0000000005020100, 0x0000000000050201, 0x0000000000050200,
+    0x0000000000000502, 0x0000000000050100, 0x0000000000000501,
+    0x0000000000000500, 0x0000000000000005, 0x0000000403020100,
+    0x0000000004030201, 0x0000000004030200, 0x0000000000040302,
+    0x0000000004030100, 0x0000000000040301, 0x0000000000040300,
+    0x0000000000000403, 0x0000000004020100, 0x0000000000040201,
+    0x0000000000040200, 0x0000000000000402, 0x0000000000040100,
+    0x0000000000000401, 0x0000000000000400, 0x0000000000000004,
+    0x0000000003020100, 0x0000000000030201, 0x0000000000030200,
+    0x0000000000000302, 0x0000000000030100, 0x0000000000000301,
+    0x0000000000000300, 0x0000000000000003, 0x0000000000020100,
+    0x0000000000000201, 0x0000000000000200, 0x0000000000000002,
+    0x0000000000000100, 0x0000000000000001, 0x0000000000000000,
+    0x0000000000000000,
+};
+
+constexpr uint8_t pshufb_combine_table[272] = {
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
+    0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
+    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0x00, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff,
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+    0x0f, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0a, 0x0b,
+    0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x08,
+    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0x00, 0x01, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0x00, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+    0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x08, 0x09, 0x0a, 0x0b,
+    0x0c, 0x0d, 0x0e, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+};
+
+constexpr unsigned char BitsSetTable256mul2[256] = {
+    0,  2,  2,  4,  2,  4,  4,  6,  2,  4,  4,  6,  4,  6,  6,  8,  2,  4,  4,
+    6,  4,  6,  6,  8,  4,  6,  6,  8,  6,  8,  8,  10, 2,  4,  4,  6,  4,  6,
+    6,  8,  4,  6,  6,  8,  6,  8,  8,  10, 4,  6,  6,  8,  6,  8,  8,  10, 6,
+    8,  8,  10, 8,  10, 10, 12, 2,  4,  4,  6,  4,  6,  6,  8,  4,  6,  6,  8,
+    6,  8,  8,  10, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,  10, 8,  10, 10,
+    12, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,  10, 8,  10, 10, 12, 6,  8,
+    8,  10, 8,  10, 10, 12, 8,  10, 10, 12, 10, 12, 12, 14, 2,  4,  4,  6,  4,
+    6,  6,  8,  4,  6,  6,  8,  6,  8,  8,  10, 4,  6,  6,  8,  6,  8,  8,  10,
+    6,  8,  8,  10, 8,  10, 10, 12, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,
+    10, 8,  10, 10, 12, 6,  8,  8,  10, 8,  10, 10, 12, 8,  10, 10, 12, 10, 12,
+    12, 14, 4,  6,  6,  8,  6,  8,  8,  10, 6,  8,  8,  10, 8,  10, 10, 12, 6,
+    8,  8,  10, 8,  10, 10, 12, 8,  10, 10, 12, 10, 12, 12, 14, 6,  8,  8,  10,
+    8,  10, 10, 12, 8,  10, 10, 12, 10, 12, 12, 14, 8,  10, 10, 12, 10, 12, 12,
+    14, 10, 12, 12, 14, 12, 14, 14, 16};
+
+constexpr uint8_t to_base64_value[] = {
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
+    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
+    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255};
+
+constexpr uint8_t to_base64_url_value[] = {
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    62,  255, 255, 52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
+    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+    25,  255, 255, 255, 255, 63,  255, 26,  27,  28,  29,  30,  31,  32,  33,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255};
+
+constexpr uint8_t to_base64_default_or_url_value[] = {
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 64,  64,  255, 64,  64,  255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 64,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
+    62,  255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
+    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+    25,  255, 255, 255, 255, 63,  255, 26,  27,  28,  29,  30,  31,  32,  33,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255};
+
+static_assert(sizeof(to_base64_value) == 256,
+              "to_base64_value must have 256 elements");
+static_assert(sizeof(to_base64_url_value) == 256,
+              "to_base64_url_value must have 256 elements");
+static_assert(to_base64_value[uint8_t(' ')] == 64,
+              "space must be == 64 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t(' ')] == 64,
+              "space must be == 64 in to_base64_url_value");
+static_assert(to_base64_value[uint8_t('\t')] == 64,
+              "tab must be == 64 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t('\t')] == 64,
+              "tab must be == 64 in to_base64_url_value");
+static_assert(to_base64_value[uint8_t('\r')] == 64,
+              "cr must be == 64 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t('\r')] == 64,
+              "cr must be == 64 in to_base64_url_value");
+static_assert(to_base64_value[uint8_t('\n')] == 64,
+              "lf must be == 64 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t('\n')] == 64,
+              "lf must be == 64 in to_base64_url_value");
+static_assert(to_base64_value[uint8_t('\f')] == 64,
+              "ff must be == 64 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t('\f')] == 64,
+              "ff must be == 64 in to_base64_url_value");
+static_assert(to_base64_value[uint8_t('+')] == 62,
+              "+ must be == 62 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t('-')] == 62,
+              "- must be == 62 in to_base64_url_value");
+static_assert(to_base64_value[uint8_t('/')] == 63,
+              "/ must be == 63 in to_base64_value");
+static_assert(to_base64_url_value[uint8_t('_')] == 63,
+              "_ must be == 63 in to_base64_url_value");
+} // namespace base64
+} // namespace tables
+} // unnamed namespace
+} // namespace simdutf
+
+#endif // SIMDUTF_BASE64_TABLES_H
+/* end file include/simdutf/base64_tables.h */
+/* begin file include/simdutf/scalar/base64.h */
+#ifndef SIMDUTF_BASE64_H
+#define SIMDUTF_BASE64_H
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+namespace simdutf {
+namespace scalar {
+namespace {
+namespace base64 {
+
+// This function is not expected to be fast. Do not use in long loops.
+// In most instances you should be using is_ignorable.
+template <class char_type> bool is_ascii_white_space(char_type c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
+}
+
+template <class char_type> simdutf_constexpr23 bool is_eight_byte(char_type c) {
+  if constexpr (sizeof(char_type) == 1) {
+    return true;
+  }
+  return uint8_t(c) == c;
+}
+
+template <class char_type>
+simdutf_constexpr23 bool is_ignorable(char_type c,
+                                      simdutf::base64_options options) {
+  const uint8_t *to_base64 =
+      (options & base64_default_or_url)
+          ? tables::base64::to_base64_default_or_url_value
+          : ((options & base64_url) ? tables::base64::to_base64_url_value
+                                    : tables::base64::to_base64_value);
+  const bool ignore_garbage =
+      (options == base64_options::base64_url_accept_garbage) ||
+      (options == base64_options::base64_default_accept_garbage) ||
+      (options == base64_options::base64_default_or_url_accept_garbage);
+  uint8_t code = to_base64[uint8_t(c)];
+  if (is_eight_byte(c) && code <= 63) {
+    return false;
+  }
+  if (is_eight_byte(c) && code == 64) {
+    return true;
+  }
+  return ignore_garbage;
+}
+template <class char_type>
+simdutf_constexpr23 bool is_base64(char_type c,
+                                   simdutf::base64_options options) {
+  const uint8_t *to_base64 =
+      (options & base64_default_or_url)
+          ? tables::base64::to_base64_default_or_url_value
+          : ((options & base64_url) ? tables::base64::to_base64_url_value
+                                    : tables::base64::to_base64_value);
+  uint8_t code = to_base64[uint8_t(c)];
+  if (is_eight_byte(c) && code <= 63) {
+    return true;
+  }
+  return false;
+}
+
+template <class char_type>
+simdutf_constexpr23 bool is_base64_or_padding(char_type c,
+                                              simdutf::base64_options options) {
+  const uint8_t *to_base64 =
+      (options & base64_default_or_url)
+          ? tables::base64::to_base64_default_or_url_value
+          : ((options & base64_url) ? tables::base64::to_base64_url_value
+                                    : tables::base64::to_base64_value);
+  if (c == '=') {
+    return true;
+  }
+  uint8_t code = to_base64[uint8_t(c)];
+  if (is_eight_byte(c) && code <= 63) {
+    return true;
+  }
+  return false;
+}
+
+template <class char_type>
+bool is_ignorable_or_padding(char_type c, simdutf::base64_options options) {
+  return is_ignorable(c, options) || c == '=';
+}
+
+struct reduced_input {
+  size_t equalsigns;    // number of padding characters '=', typically 0, 1, 2.
+  size_t equallocation; // location of the first padding character if any
+  size_t srclen;        // length of the input buffer before padding
+  size_t full_input_length; // length of the input buffer with padding but
+                            // without ignorable characters
+};
+
+// find the end of the base64 input buffer
+// It returns the number of padding characters, the location of the first
+// padding character if any, the length of the input buffer before padding
+// and the length of the input buffer with padding. The input buffer is not
+// modified. The function assumes that there are at most two padding characters.
+template <class char_type>
+simdutf_constexpr23 reduced_input find_end(const char_type *src, size_t srclen,
+                                           simdutf::base64_options options) {
+  const uint8_t *to_base64 =
+      (options & base64_default_or_url)
+          ? tables::base64::to_base64_default_or_url_value
+          : ((options & base64_url) ? tables::base64::to_base64_url_value
+                                    : tables::base64::to_base64_value);
+  const bool ignore_garbage =
+      (options == base64_options::base64_url_accept_garbage) ||
+      (options == base64_options::base64_default_accept_garbage) ||
+      (options == base64_options::base64_default_or_url_accept_garbage);
+
+  size_t equalsigns = 0;
+  // We intentionally include trailing spaces in the full input length.
+  // See https://github.com/simdutf/simdutf/issues/824
+  size_t full_input_length = srclen;
+  // skip trailing spaces
+  while (!ignore_garbage && srclen > 0 &&
+         scalar::base64::is_eight_byte(src[srclen - 1]) &&
+         to_base64[uint8_t(src[srclen - 1])] == 64) {
+    srclen--;
+  }
+  size_t equallocation =
+      srclen; // location of the first padding character if any
+  if (ignore_garbage) {
+    // Technically, we don't need to find the first padding character, we can
+    // just change our algorithms, but it adds substantial complexity.
+    auto it = simdutf::find(src, src + srclen, '=');
+    if (it != src + srclen) {
+      equallocation = it - src;
+      equalsigns = 1;
+      srclen = equallocation;
+      full_input_length = equallocation + 1;
+    }
+    return {equalsigns, equallocation, srclen, full_input_length};
+  }
+  if (!ignore_garbage && srclen > 0 && src[srclen - 1] == '=') {
+    // This is the last '=' sign.
+    equallocation = srclen - 1;
+    srclen--;
+    equalsigns = 1;
+    // skip trailing spaces
+    while (srclen > 0 && scalar::base64::is_eight_byte(src[srclen - 1]) &&
+           to_base64[uint8_t(src[srclen - 1])] == 64) {
+      srclen--;
+    }
+    if (srclen > 0 && src[srclen - 1] == '=') {
+      // This is the second '=' sign.
+      equallocation = srclen - 1;
+      srclen--;
+      equalsigns = 2;
+    }
+  }
+  return {equalsigns, equallocation, srclen, full_input_length};
+}
+
+// Returns true upon success. The destination buffer must be large enough.
+// This functions assumes that the padding (=) has been removed.
+// if check_capacity is true, it will check that the destination buffer is
+// large enough. If it is not, it will return OUTPUT_BUFFER_TOO_SMALL.
+template <bool check_capacity, class char_type>
+simdutf_constexpr23 full_result base64_tail_decode_impl(
+    char *dst, size_t outlen, const char_type *src, size_t length,
+    size_t padding_characters, // number of padding characters
+                               // '=', typically 0, 1, 2.
+    base64_options options, last_chunk_handling_options last_chunk_options) {
+  char *dstend = dst + outlen;
+  (void)dstend;
+  // This looks like 10 branches, but we expect the compiler to resolve this to
+  // two branches (easily predicted):
+  const uint8_t *to_base64 =
+      (options & base64_default_or_url)
+          ? tables::base64::to_base64_default_or_url_value
+          : ((options & base64_url) ? tables::base64::to_base64_url_value
+                                    : tables::base64::to_base64_value);
+  const uint32_t *d0 =
+      (options & base64_default_or_url)
+          ? tables::base64::base64_default_or_url::d0
+          : ((options & base64_url) ? tables::base64::base64_url::d0
+                                    : tables::base64::base64_default::d0);
+  const uint32_t *d1 =
+      (options & base64_default_or_url)
+          ? tables::base64::base64_default_or_url::d1
+          : ((options & base64_url) ? tables::base64::base64_url::d1
+                                    : tables::base64::base64_default::d1);
+  const uint32_t *d2 =
+      (options & base64_default_or_url)
+          ? tables::base64::base64_default_or_url::d2
+          : ((options & base64_url) ? tables::base64::base64_url::d2
+                                    : tables::base64::base64_default::d2);
+  const uint32_t *d3 =
+      (options & base64_default_or_url)
+          ? tables::base64::base64_default_or_url::d3
+          : ((options & base64_url) ? tables::base64::base64_url::d3
+                                    : tables::base64::base64_default::d3);
+  const bool ignore_garbage =
+      (options == base64_options::base64_url_accept_garbage) ||
+      (options == base64_options::base64_default_accept_garbage) ||
+      (options == base64_options::base64_default_or_url_accept_garbage);
+
+  const char_type *srcend = src + length;
+  const char_type *srcinit = src;
+  const char *dstinit = dst;
+
+  uint32_t x;
+  size_t idx;
+  uint8_t buffer[4];
+  while (true) {
+    while (srcend - src >= 4 && is_eight_byte(src[0]) &&
+           is_eight_byte(src[1]) && is_eight_byte(src[2]) &&
+           is_eight_byte(src[3]) &&
+           (x = d0[uint8_t(src[0])] | d1[uint8_t(src[1])] |
+                d2[uint8_t(src[2])] | d3[uint8_t(src[3])]) < 0x01FFFFFF) {
+      if (check_capacity && dstend - dst < 3) {
+        return {OUTPUT_BUFFER_TOO_SMALL, size_t(src - srcinit),
+                size_t(dst - dstinit)};
+      }
+      *dst++ = static_cast<char>(x & 0xFF);
+      *dst++ = static_cast<char>((x >> 8) & 0xFF);
+      *dst++ = static_cast<char>((x >> 16) & 0xFF);
+      src += 4;
+    }
+    const char_type *srccur = src;
+    idx = 0;
+    // we need at least four characters.
+#ifdef __clang__
+    // If possible, we read four characters at a time. (It is an optimization.)
+    if (ignore_garbage && src + 4 <= srcend) {
+      char_type c0 = src[0];
+      char_type c1 = src[1];
+      char_type c2 = src[2];
+      char_type c3 = src[3];
+
+      uint8_t code0 = to_base64[uint8_t(c0)];
+      uint8_t code1 = to_base64[uint8_t(c1)];
+      uint8_t code2 = to_base64[uint8_t(c2)];
+      uint8_t code3 = to_base64[uint8_t(c3)];
+
+      buffer[idx] = code0;
+      idx += (is_eight_byte(c0) && code0 <= 63);
+      buffer[idx] = code1;
+      idx += (is_eight_byte(c1) && code1 <= 63);
+      buffer[idx] = code2;
+      idx += (is_eight_byte(c2) && code2 <= 63);
+      buffer[idx] = code3;
+      idx += (is_eight_byte(c3) && code3 <= 63);
+      src += 4;
+    }
+#endif
+    while ((idx < 4) && (src < srcend)) {
+      char_type c = *src;
+
+      uint8_t code = to_base64[uint8_t(c)];
+      buffer[idx] = uint8_t(code);
+      if (is_eight_byte(c) && code <= 63) {
+        idx++;
+      } else if (!ignore_garbage &&
+                 (code > 64 || !scalar::base64::is_eight_byte(c))) {
+        return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
+                size_t(dst - dstinit)};
+      } else {
+        // We have a space or a newline or garbage. We ignore it.
+      }
+      src++;
+    }
+    if (idx != 4) {
+      simdutf_log_assert(idx < 4, "idx should be less than 4");
+      // We never should have that the number of base64 characters + the
+      // number of padding characters is more than 4.
+      if (!ignore_garbage && (idx + padding_characters > 4)) {
+        return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
+                size_t(dst - dstinit), true};
+      }
+
+      // The idea here is that in loose mode,
+      // if there is padding at all, it must be used
+      // to form 4-wise chunk. However, in loose mode,
+      // we do accept no padding at all.
+      if (!ignore_garbage &&
+          last_chunk_options == last_chunk_handling_options::loose &&
+          (idx >= 2) && padding_characters > 0 &&
+          ((idx + padding_characters) & 3) != 0) {
+        return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
+                size_t(dst - dstinit), true};
+      } else
+
+        // The idea here is that in strict mode, we do not want to accept
+        // incomplete base64 chunks. So if the chunk was otherwise valid, we
+        // return BASE64_INPUT_REMAINDER.
+        if (!ignore_garbage &&
+            last_chunk_options == last_chunk_handling_options::strict &&
+            (idx >= 2) && ((idx + padding_characters) & 3) != 0) {
+          // The partial chunk was at src - idx
+          return {BASE64_INPUT_REMAINDER, size_t(src - srcinit),
+                  size_t(dst - dstinit), true};
+        } else
+          // If there is a partial chunk with insufficient padding, with
+          // stop_before_partial, we need to just ignore it. In "only full"
+          // mode, skip the minute there are padding characters.
+          if ((last_chunk_options ==
+                   last_chunk_handling_options::stop_before_partial &&
+               (padding_characters + idx < 4) && (idx != 0) &&
+               (idx >= 2 || padding_characters == 0)) ||
+              (last_chunk_options ==
+                   last_chunk_handling_options::only_full_chunks &&
+               (idx >= 2 || padding_characters == 0))) {
+            // partial means that we are *not* going to consume the read
+            // characters. We need to rewind the src pointer.
+            src = srccur;
+            return {SUCCESS, size_t(src - srcinit), size_t(dst - dstinit)};
+          } else {
+            if (idx == 2) {
+              uint32_t triple = (uint32_t(buffer[0]) << 3 * 6) +
+                                (uint32_t(buffer[1]) << 2 * 6);
+              if (!ignore_garbage &&
+                  (last_chunk_options == last_chunk_handling_options::strict) &&
+                  (triple & 0xffff)) {
+                return {BASE64_EXTRA_BITS, size_t(src - srcinit),
+                        size_t(dst - dstinit)};
+              }
+              if (check_capacity && dstend - dst < 1) {
+                return {OUTPUT_BUFFER_TOO_SMALL, size_t(srccur - srcinit),
+                        size_t(dst - dstinit)};
+              }
+              *dst++ = static_cast<char>((triple >> 16) & 0xFF);
+            } else if (idx == 3) {
+              uint32_t triple = (uint32_t(buffer[0]) << 3 * 6) +
+                                (uint32_t(buffer[1]) << 2 * 6) +
+                                (uint32_t(buffer[2]) << 1 * 6);
+              if (!ignore_garbage &&
+                  (last_chunk_options == last_chunk_handling_options::strict) &&
+                  (triple & 0xff)) {
+                return {BASE64_EXTRA_BITS, size_t(src - srcinit),
+                        size_t(dst - dstinit)};
+              }
+              if (check_capacity && dstend - dst < 2) {
+                return {OUTPUT_BUFFER_TOO_SMALL, size_t(srccur - srcinit),
+                        size_t(dst - dstinit)};
+              }
+              *dst++ = static_cast<char>((triple >> 16) & 0xFF);
+              *dst++ = static_cast<char>((triple >> 8) & 0xFF);
+            } else if (!ignore_garbage && idx == 1 &&
+                       (!is_partial(last_chunk_options) ||
+                        (is_partial(last_chunk_options) &&
+                         padding_characters > 0))) {
+              return {BASE64_INPUT_REMAINDER, size_t(src - srcinit),
+                      size_t(dst - dstinit)};
+            } else if (!ignore_garbage && idx == 0 && padding_characters > 0) {
+              return {INVALID_BASE64_CHARACTER, size_t(src - srcinit),
+                      size_t(dst - dstinit), true};
+            }
+            return {SUCCESS, size_t(src - srcinit), size_t(dst - dstinit)};
+          }
+    }
+    if (check_capacity && dstend - dst < 3) {
+      return {OUTPUT_BUFFER_TOO_SMALL, size_t(srccur - srcinit),
+              size_t(dst - dstinit)};
+    }
+    uint32_t triple =
+        (uint32_t(buffer[0]) << 3 * 6) + (uint32_t(buffer[1]) << 2 * 6) +
+        (uint32_t(buffer[2]) << 1 * 6) + (uint32_t(buffer[3]) << 0 * 6);
+    *dst++ = static_cast<char>((triple >> 16) & 0xFF);
+    *dst++ = static_cast<char>((triple >> 8) & 0xFF);
+    *dst++ = static_cast<char>(triple & 0xFF);
+  }
+}
+
+template <class char_type>
+simdutf_constexpr23 full_result base64_tail_decode(
+    char *dst, const char_type *src, size_t length,
+    size_t padding_characters, // number of padding characters
+                               // '=', typically 0, 1, 2.
+    base64_options options, last_chunk_handling_options last_chunk_options) {
+  return base64_tail_decode_impl<false>(dst, 0, src, length, padding_characters,
+                                        options, last_chunk_options);
+}
+
+// like base64_tail_decode, but it will not write past the end of the output
+// buffer. The outlen parameter is modified to reflect the number of bytes
+// written. This functions assumes that the padding (=) has been removed.
+//
+template <class char_type>
+simdutf_constexpr23 full_result base64_tail_decode_safe(
+    char *dst, size_t outlen, const char_type *src, size_t length,
+    size_t padding_characters, // number of padding characters
+                               // '=', typically 0, 1, 2.
+    base64_options options, last_chunk_handling_options last_chunk_options) {
+  return base64_tail_decode_impl<true>(dst, outlen, src, length,
+                                       padding_characters, options,
+                                       last_chunk_options);
+}
+
+inline simdutf_constexpr23 full_result
+patch_tail_result(full_result r, size_t previous_input, size_t previous_output,
+                  size_t equallocation, size_t full_input_length,
+                  last_chunk_handling_options last_chunk_options) {
+  r.input_count += previous_input;
+  r.output_count += previous_output;
+  if (r.padding_error) {
+    r.input_count = equallocation;
+  }
+
+  if (r.error == error_code::SUCCESS) {
+    if (!is_partial(last_chunk_options)) {
+      // A success when we are not in stop_before_partial mode.
+      // means that we have consumed the whole input buffer.
+      r.input_count = full_input_length;
+    } else if (r.output_count % 3 != 0) {
+      r.input_count = full_input_length;
+    }
+  }
+  return r;
+}
+
+// Returns the number of bytes written. The destination buffer must be large
+// enough. It will add padding (=) if needed.
+template <bool use_lines = false>
+simdutf_constexpr23 size_t tail_encode_base64_impl(
+    char *dst, const char *src, size_t srclen, base64_options options,
+    size_t line_length = simdutf::default_line_length, size_t line_offset = 0) {
+  if constexpr (use_lines) {
+    // sanitize line_length and starting_line_offset.
+    // line_length must be greater than 3.
+    if (line_length < 4) {
+      line_length = 4;
+    }
+    simdutf_log_assert(line_offset <= line_length,
+                       "line_offset should be less than line_length");
+  }
+  // By default, we use padding if we are not using the URL variant.
+  // This is check with ((options & base64_url) == 0) which returns true if we
+  // are not using the URL variant. However, we also allow 'inversion' of the
+  // convention with the base64_reverse_padding option. If the
+  // base64_reverse_padding option is set, we use padding if we are using the
+  // URL variant, and we omit it if we are not using the URL variant. This is
+  // checked with
+  // ((options & base64_reverse_padding) == base64_reverse_padding).
+  bool use_padding =
+      ((options & base64_url) == 0) ^
+      ((options & base64_reverse_padding) == base64_reverse_padding);
+  // This looks like 3 branches, but we expect the compiler to resolve this to
+  // a single branch:
+  const char *e0 = (options & base64_url) ? tables::base64::base64_url::e0
+                                          : tables::base64::base64_default::e0;
+  const char *e1 = (options & base64_url) ? tables::base64::base64_url::e1
+                                          : tables::base64::base64_default::e1;
+  const char *e2 = (options & base64_url) ? tables::base64::base64_url::e2
+                                          : tables::base64::base64_default::e2;
+  char *out = dst;
+  size_t i = 0;
+  uint8_t t1, t2, t3;
+  for (; i + 2 < srclen; i += 3) {
+    t1 = uint8_t(src[i]);
+    t2 = uint8_t(src[i + 1]);
+    t3 = uint8_t(src[i + 2]);
+    if constexpr (use_lines) {
+      if (line_offset + 3 >= line_length) {
+        if (line_offset == line_length) {
+          *out++ = '\n';
+          *out++ = e0[t1];
+          *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+          *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+          *out++ = e2[t3];
+          line_offset = 4;
+        } else if (line_offset + 1 == line_length) {
+          *out++ = e0[t1];
+          *out++ = '\n';
+          *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+          *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+          *out++ = e2[t3];
+          line_offset = 3;
+        } else if (line_offset + 2 == line_length) {
+          *out++ = e0[t1];
+          *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+          *out++ = '\n';
+          *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+          *out++ = e2[t3];
+          line_offset = 2;
+        } else if (line_offset + 3 == line_length) {
+          *out++ = e0[t1];
+          *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+          *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+          *out++ = '\n';
+          *out++ = e2[t3];
+          line_offset = 1;
+        }
+      } else {
+        *out++ = e0[t1];
+        *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+        *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+        *out++ = e2[t3];
+        line_offset += 4;
+      }
+    } else {
+      *out++ = e0[t1];
+      *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+      *out++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+      *out++ = e2[t3];
+    }
+  }
+  switch (srclen - i) {
+  case 0:
+    break;
+  case 1:
+    t1 = uint8_t(src[i]);
+    if constexpr (use_lines) {
+      if (use_padding) {
+        if (line_offset + 3 >= line_length) {
+          if (line_offset == line_length) {
+            *out++ = '\n';
+            *out++ = e0[t1];
+            *out++ = e1[(t1 & 0x03) << 4];
+            *out++ = '=';
+            *out++ = '=';
+          } else if (line_offset + 1 == line_length) {
+            *out++ = e0[t1];
+            *out++ = '\n';
+            *out++ = e1[(t1 & 0x03) << 4];
+            *out++ = '=';
+            *out++ = '=';
+          } else if (line_offset + 2 == line_length) {
+            *out++ = e0[t1];
+            *out++ = e1[(t1 & 0x03) << 4];
+            *out++ = '\n';
+            *out++ = '=';
+            *out++ = '=';
+          } else if (line_offset + 3 == line_length) {
+            *out++ = e0[t1];
+            *out++ = e1[(t1 & 0x03) << 4];
+            *out++ = '=';
+            *out++ = '\n';
+            *out++ = '=';
+          }
+        } else {
+          *out++ = e0[t1];
+          *out++ = e1[(t1 & 0x03) << 4];
+          *out++ = '=';
+          *out++ = '=';
+        }
+      } else {
+        if (line_offset + 2 >= line_length) {
+          if (line_offset == line_length) {
+            *out++ = '\n';
+            *out++ = e0[uint8_t(src[i])];
+            *out++ = e1[(uint8_t(src[i]) & 0x03) << 4];
+          } else if (line_offset + 1 == line_length) {
+            *out++ = e0[uint8_t(src[i])];
+            *out++ = '\n';
+            *out++ = e1[(uint8_t(src[i]) & 0x03) << 4];
+          } else {
+            *out++ = e0[uint8_t(src[i])];
+            *out++ = e1[(uint8_t(src[i]) & 0x03) << 4];
+            // *out++ = '\n'; ==> no newline at the end of the output
+          }
+        } else {
+          *out++ = e0[uint8_t(src[i])];
+          *out++ = e1[(uint8_t(src[i]) & 0x03) << 4];
+        }
+      }
+    } else {
+      *out++ = e0[t1];
+      *out++ = e1[(t1 & 0x03) << 4];
+      if (use_padding) {
+        *out++ = '=';
+        *out++ = '=';
+      }
+    }
+    break;
+  default: /* case 2 */
+    t1 = uint8_t(src[i]);
+    t2 = uint8_t(src[i + 1]);
+    if constexpr (use_lines) {
+      if (use_padding) {
+        if (line_offset + 3 >= line_length) {
+          if (line_offset == line_length) {
+            *out++ = '\n';
+            *out++ = e0[t1];
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = e2[(t2 & 0x0F) << 2];
+            *out++ = '=';
+          } else if (line_offset + 1 == line_length) {
+            *out++ = e0[t1];
+            *out++ = '\n';
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = e2[(t2 & 0x0F) << 2];
+            *out++ = '=';
+          } else if (line_offset + 2 == line_length) {
+            *out++ = e0[t1];
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = '\n';
+            *out++ = e2[(t2 & 0x0F) << 2];
+            *out++ = '=';
+          } else if (line_offset + 3 == line_length) {
+            *out++ = e0[t1];
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = e2[(t2 & 0x0F) << 2];
+            *out++ = '\n';
+            *out++ = '=';
+          }
+        } else {
+          *out++ = e0[t1];
+          *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+          *out++ = e2[(t2 & 0x0F) << 2];
+          *out++ = '=';
+        }
+      } else {
+        if (line_offset + 3 >= line_length) {
+          if (line_offset == line_length) {
+            *out++ = '\n';
+            *out++ = e0[t1];
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = e2[(t2 & 0x0F) << 2];
+          } else if (line_offset + 1 == line_length) {
+            *out++ = e0[t1];
+            *out++ = '\n';
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = e2[(t2 & 0x0F) << 2];
+          } else if (line_offset + 2 == line_length) {
+            *out++ = e0[t1];
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = '\n';
+            *out++ = e2[(t2 & 0x0F) << 2];
+          } else {
+            *out++ = e0[t1];
+            *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *out++ = e2[(t2 & 0x0F) << 2];
+            // *out++ = '\n'; ==> no newline at the end of the output
+          }
+        } else {
+          *out++ = e0[t1];
+          *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+          *out++ = e2[(t2 & 0x0F) << 2];
+        }
+      }
+    } else {
+      *out++ = e0[t1];
+      *out++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+      *out++ = e2[(t2 & 0x0F) << 2];
+      if (use_padding) {
+        *out++ = '=';
+      }
+    }
+  }
+  return (size_t)(out - dst);
+}
+
+// Returns the number of bytes written. The destination buffer must be large
+// enough. It will add padding (=) if needed.
+inline simdutf_constexpr23 size_t tail_encode_base64(char *dst, const char *src,
+                                                     size_t srclen,
+                                                     base64_options options) {
+  return tail_encode_base64_impl(dst, src, srclen, options);
+}
+
+template <class InputPtr>
+simdutf_warn_unused simdutf_constexpr23 size_t
+maximal_binary_length_from_base64(InputPtr input, size_t length) noexcept {
+  // We process the padding characters ('=') at the end to make sure
+  // that we return an exact result when the input has no ignorable characters
+  // (e.g., spaces).
+  size_t padding = 0;
+  if (length > 0) {
+    if (input[length - 1] == '=') {
+      padding++;
+      if (length > 1 && input[length - 2] == '=') {
+        padding++;
+      }
+    }
+  }
+  // The input is not otherwise processed for ignorable characters or
+  // validation, so that the function runs in constant time (very fast). In
+  // practice, base64 inputs without ignorable characters are common and the
+  // common case are line separated inputs with relatively long lines (e.g., 76
+  // characters) which leads this function to a slight (1%) overestimation of
+  // the output size.
+  //
+  // Of course, some inputs might contain an arbitrary number of spaces or
+  // newlines, which would make this function return a very pessimistic output
+  // size but systems that produce base64 outputs typically do not do that and
+  // if they do, they do not care much about minimizing memory usage.
+  //
+  // In specialized applications, users may know that their input is line
+  // separated, which can be checked very quickly by by iterating (e.g., over 76
+  // character chunks, looking for the linefeed characters only). We could
+  // provide a specialized function for that, but it is not clear that the added
+  // complexity is worth it for us.
+  //
+  size_t actual_length = length - padding;
+  if (actual_length % 4 <= 1) {
+    return actual_length / 4 * 3;
+  }
+  // if we have a valid input, then the remainder must be 2 or 3 adding one or
+  // two extra bytes.
+  return actual_length / 4 * 3 + (actual_length % 4) - 1;
+}
+
+// This function computes the binary length by iterating through the input
+// and counting non-whitespace characters (excluding padding characters).
+// We use a simple check (c > ' ') which is easy to parallelize and matches
+// SIMD behavior. Only the last few characters are checked for padding '='.
+template <class char_type>
+simdutf_warn_unused simdutf_constexpr23 size_t
+binary_length_from_base64(const char_type *input, size_t length) noexcept {
+  // Count non-whitespace characters (c > ' ') with loop unrolling
+  size_t count = 0;
+  for (size_t i = 0; i < length; i++) {
+    count += (input[i] > ' ');
+  }
+
+  // Check for padding '=' at the end (at most 2 padding characters)
+  // Scan backwards, skipping whitespace, to find padding
+  size_t padding = 0;
+  size_t pos = length;
+  // Skip trailing whitespace
+  while (pos > 0 && padding < 2) {
+    char_type c = input[--pos];
+    if (c == '=') {
+      padding++;
+    } else if (c > ' ') {
+      break;
+    }
+  }
+  return ((count - padding) * 3) / 4;
+}
+
+template <typename char_type>
+simdutf_warn_unused simdutf_constexpr23 full_result
+base64_to_binary_details_impl(
+    const char_type *input, size_t length, char *output, base64_options options,
+    last_chunk_handling_options last_chunk_options) noexcept {
+  const bool ignore_garbage =
+      (options == base64_options::base64_url_accept_garbage) ||
+      (options == base64_options::base64_default_accept_garbage) ||
+      (options == base64_options::base64_default_or_url_accept_garbage);
+  auto ri = simdutf::scalar::base64::find_end(input, length, options);
+  size_t equallocation = ri.equallocation;
+  size_t equalsigns = ri.equalsigns;
+  length = ri.srclen;
+  size_t full_input_length = ri.full_input_length;
+  if (length == 0) {
+    if (!ignore_garbage && equalsigns > 0) {
+      return {INVALID_BASE64_CHARACTER, equallocation, 0, true};
+    }
+    return {SUCCESS, full_input_length, 0};
+  }
+  full_result r = scalar::base64::base64_tail_decode(
+      output, input, length, equalsigns, options, last_chunk_options);
+  r = scalar::base64::patch_tail_result(r, 0, 0, equallocation,
+                                        full_input_length, last_chunk_options);
+  if (!is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
+      equalsigns > 0 && !ignore_garbage) {
+    // additional checks
+    if ((r.output_count % 3 == 0) ||
+        ((r.output_count % 3) + 1 + equalsigns != 4)) {
+      return {INVALID_BASE64_CHARACTER, equallocation, r.output_count, true};
+    }
+  }
+  // When is_partial(last_chunk_options) is true, we must either end with
+  // the end of the stream (beyond whitespace) or right after a non-ignorable
+  // character or at the very beginning of the stream.
+  // See https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
+  if (is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
+      r.input_count < full_input_length) {
+    // First check if we can extend the input to the end of the stream
+    while (r.input_count < full_input_length &&
+           base64_ignorable(*(input + r.input_count), options)) {
+      r.input_count++;
+    }
+    // If we are still not at the end of the stream, then we must backtrack
+    // to the last non-ignorable character.
+    if (r.input_count < full_input_length) {
+      while (r.input_count > 0 &&
+             base64_ignorable(*(input + r.input_count - 1), options)) {
+        r.input_count--;
+      }
+    }
+  }
+  return r;
+}
+
+template <typename char_type>
+simdutf_constexpr23 simdutf_warn_unused full_result
+base64_to_binary_details_safe_impl(
+    const char_type *input, size_t length, char *output, size_t outlen,
+    base64_options options,
+    last_chunk_handling_options last_chunk_options) noexcept {
+  const bool ignore_garbage =
+      (options == base64_options::base64_url_accept_garbage) ||
+      (options == base64_options::base64_default_accept_garbage) ||
+      (options == base64_options::base64_default_or_url_accept_garbage);
+  auto ri = simdutf::scalar::base64::find_end(input, length, options);
+  size_t equallocation = ri.equallocation;
+  size_t equalsigns = ri.equalsigns;
+  length = ri.srclen;
+  size_t full_input_length = ri.full_input_length;
+  if (length == 0) {
+    if (!ignore_garbage && equalsigns > 0) {
+      return {INVALID_BASE64_CHARACTER, equallocation, 0};
+    }
+    return {SUCCESS, full_input_length, 0};
+  }
+  full_result r = scalar::base64::base64_tail_decode_safe(
+      output, outlen, input, length, equalsigns, options, last_chunk_options);
+  r = scalar::base64::patch_tail_result(r, 0, 0, equallocation,
+                                        full_input_length, last_chunk_options);
+  if (!is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
+      equalsigns > 0 && !ignore_garbage) {
+    // additional checks
+    if ((r.output_count % 3 == 0) ||
+        ((r.output_count % 3) + 1 + equalsigns != 4)) {
+      return {INVALID_BASE64_CHARACTER, equallocation, r.output_count};
+    }
+  }
+
+  // When is_partial(last_chunk_options) is true, we must either end with
+  // the end of the stream (beyond whitespace) or right after a non-ignorable
+  // character or at the very beginning of the stream.
+  // See https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
+  if (is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
+      r.input_count < full_input_length) {
+    // First check if we can extend the input to the end of the stream
+    while (r.input_count < full_input_length &&
+           base64_ignorable(*(input + r.input_count), options)) {
+      r.input_count++;
+    }
+    // If we are still not at the end of the stream, then we must backtrack
+    // to the last non-ignorable character.
+    if (r.input_count < full_input_length) {
+      while (r.input_count > 0 &&
+             base64_ignorable(*(input + r.input_count - 1), options)) {
+        r.input_count--;
+      }
+    }
+  }
+  return r;
+}
+
+simdutf_warn_unused simdutf_constexpr23 size_t
+base64_length_from_binary(size_t length, base64_options options) noexcept {
+  // By default, we use padding if we are not using the URL variant.
+  // This is check with ((options & base64_url) == 0) which returns true if we
+  // are not using the URL variant. However, we also allow 'inversion' of the
+  // convention with the base64_reverse_padding option. If the
+  // base64_reverse_padding option is set, we use padding if we are using the
+  // URL variant, and we omit it if we are not using the URL variant. This is
+  // checked with
+  // ((options & base64_reverse_padding) == base64_reverse_padding).
+  bool use_padding =
+      ((options & base64_url) == 0) ^
+      ((options & base64_reverse_padding) == base64_reverse_padding);
+  if (!use_padding) {
+    return length / 3 * 4 + ((length % 3) ? (length % 3) + 1 : 0);
+  }
+  return (length + 2) / 3 *
+         4; // We use padding to make the length a multiple of 4.
+}
+
+simdutf_warn_unused simdutf_constexpr23 size_t
+base64_length_from_binary_with_lines(size_t length, base64_options options,
+                                     size_t line_length) noexcept {
+  if (length == 0) {
+    return 0;
+  }
+  size_t base64_length =
+      scalar::base64::base64_length_from_binary(length, options);
+  if (line_length < 4) {
+    line_length = 4;
+  }
+  size_t lines =
+      (base64_length + line_length - 1) / line_length; // number of lines
+  return base64_length + lines - 1;
+}
+
+// Return the length of the prefix that contains count base64 characters.
+// Thus, if count is 3, the function returns the length of the prefix
+// that contains 3 base64 characters.
+// The function returns (size_t)-1 if there is not enough base64 characters in
+// the input.
+template <typename char_type>
+simdutf_warn_unused size_t prefix_length(size_t count,
+                                         simdutf::base64_options options,
+                                         const char_type *input,
+                                         size_t length) noexcept {
+  size_t i = 0;
+  while (i < length && is_ignorable(input[i], options)) {
+    i++;
+  }
+  if (count == 0) {
+    return i; // duh!
+  }
+  for (; i < length; i++) {
+    if (is_ignorable(input[i], options)) {
+      continue;
+    }
+    // We have a base64 character or a padding character.
+    count--;
+    if (count == 0) {
+      return i + 1;
+    }
+  }
+  simdutf_log_assert(false, "You never get here");
+
+  return -1; // should never happen
+}
+
+} // namespace base64
+} // unnamed namespace
+} // namespace scalar
+} // namespace simdutf
+
+#endif
+/* end file include/simdutf/scalar/base64.h */
+
+namespace simdutf {
+
+inline std::string_view to_string(base64_options options) {
+  switch (options) {
+  case base64_default:
+    return "base64_default";
+  case base64_url:
+    return "base64_url";
+  case base64_reverse_padding:
+    return "base64_reverse_padding";
+  case base64_url_with_padding:
+    return "base64_url_with_padding";
+  case base64_default_accept_garbage:
+    return "base64_default_accept_garbage";
+  case base64_url_accept_garbage:
+    return "base64_url_accept_garbage";
+  case base64_default_or_url:
+    return "base64_default_or_url";
+  case base64_default_or_url_accept_garbage:
+    return "base64_default_or_url_accept_garbage";
+  }
+  return "<unknown>";
+}
+
+inline std::string_view to_string(last_chunk_handling_options options) {
+  switch (options) {
+  case loose:
+    return "loose";
+  case strict:
+    return "strict";
+  case stop_before_partial:
+    return "stop_before_partial";
+  case only_full_chunks:
+    return "only_full_chunks";
+  }
+  return "<unknown>";
+}
+
+/**
+ * Provide the maximal binary length in bytes given the base64 input.
+ * As long as the input does not contain ignorable characters (e.g., ASCII
+ * spaces or linefeed characters), the result is exact. In particular, the
+ * function checks for padding characters.
+ *
+ * The function is fast (constant time). It checks up to two characters at
+ * the end of the string. The input is not otherwise validated or read.
+ *
+ * @param input         the base64 input to process
+ * @param length        the length of the base64 input in bytes
+ * @return maximum number of binary bytes
+ */
+simdutf_warn_unused size_t
+maximal_binary_length_from_base64(const char *input, size_t length) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t
+maximal_binary_length_from_base64(
+    const detail::input_span_of_byte_like auto &input) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::maximal_binary_length_from_base64(
+        detail::constexpr_cast_ptr<uint8_t>(input.data()), input.size());
+  } else
+    #endif
+  {
+    return maximal_binary_length_from_base64(
+        reinterpret_cast<const char *>(input.data()), input.size());
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Provide the maximal binary length in bytes given the base64 input.
+ * As long as the input does not contain ignorable characters (e.g., ASCII
+ * spaces or linefeed characters), the result is exact. In particular, the
+ * function checks for padding characters.
+ *
+ * The function is fast (constant time). It checks up to two characters at
+ * the end of the string. The input is not otherwise validated or read.
+ *
+ * @param input         the base64 input to process, in ASCII stored as 16-bit
+ * units
+ * @param length        the length of the base64 input in 16-bit units
+ * @return maximal number of binary bytes
+ */
+simdutf_warn_unused size_t maximal_binary_length_from_base64(
+    const char16_t *input, size_t length) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t
+maximal_binary_length_from_base64(std::span<const char16_t> input) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::maximal_binary_length_from_base64(input.data(),
+                                                             input.size());
+  } else
+    #endif
+  {
+    return maximal_binary_length_from_base64(input.data(), input.size());
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Compute the binary length from a base64 input.
+ * This function is useful for base64 inputs that may contain ASCII whitespaces
+ * (such as line breaks). For such inputs, the result is exact, and for any
+ * inputs the result can be used to size the output buffer passed to
+ * `base64_to_binary`.
+ *
+ * The function ignores whitespace and does not require padding characters
+ * ('=').
+ *
+ * @param input         the base64 input to process
+ * @param length        the length of the base64 input in bytes
+ * @return number of binary bytes
+ */
+simdutf_warn_unused size_t binary_length_from_base64(const char *input,
+                                                     size_t length) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t
+binary_length_from_base64(
+    const detail::input_span_of_byte_like auto &input) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::binary_length_from_base64(input.data(),
+                                                     input.size());
+  } else
+    #endif
+  {
+    return binary_length_from_base64(
+        reinterpret_cast<const char *>(input.data()), input.size());
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Compute the binary length from a base64 input.
+ * This function is useful for base64 inputs that may contain ASCII whitespaces
+ * (such as line breaks). For such inputs, the result is exact, and for any
+ * inputs the result can be used to size the output buffer passed to
+ * `base64_to_binary`.
+ *
+ * The function ignores whitespace and does not require padding characters
+ * ('=').
+ *
+ * @param input         the base64 input to process, in ASCII stored as 16-bit
+ * units
+ * @param length        the length of the base64 input in 16-bit units
+ * @return number of binary bytes
+ */
+simdutf_warn_unused size_t binary_length_from_base64(const char16_t *input,
+                                                     size_t length) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t
+binary_length_from_base64(std::span<const char16_t> input) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::binary_length_from_base64(input.data(),
+                                                     input.size());
+  } else
+    #endif
+  {
+    return binary_length_from_base64(input.data(), input.size());
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Convert a base64 input to a binary output.
+ *
+ * This function follows the WHATWG forgiving-base64 format, which means that it
+ * will ignore any ASCII spaces in the input. You may provide a padded input
+ * (with one or two equal signs at the end) or an unpadded input (without any
+ * equal signs at the end).
+ *
+ * See https://infra.spec.whatwg.org/#forgiving-base64-decode
  *
  * This function will fail in case of invalid input. When last_chunk_options =
  * loose, there are two possible reasons for failure: the input contains a
@@ -1388,15 +7167,25 @@ simdutf_warn_unused result base64_to_binary(
     base64_options options = base64_default,
     last_chunk_handling_options last_chunk_options = loose) noexcept;
   #if SIMDUTF_SPAN
-simdutf_really_inline simdutf_warn_unused result base64_to_binary(
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result
+base64_to_binary(
     const detail::input_span_of_byte_like auto &input,
     detail::output_span_of_byte_like auto &&binary_output,
     base64_options options = base64_default,
     last_chunk_handling_options last_chunk_options = loose) noexcept {
-  return base64_to_binary(reinterpret_cast<const char *>(input.data()),
-                          input.size(),
-                          reinterpret_cast<char *>(binary_output.data()),
-                          options, last_chunk_options);
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::base64_to_binary_details_impl(
+        input.data(), input.size(), binary_output.data(), options,
+        last_chunk_options);
+  } else
+    #endif
+  {
+    return base64_to_binary(reinterpret_cast<const char *>(input.data()),
+                            input.size(),
+                            reinterpret_cast<char *>(binary_output.data()),
+                            options, last_chunk_options);
+  }
 }
   #endif // SIMDUTF_SPAN
 
@@ -1406,8 +7195,27 @@ simdutf_really_inline simdutf_warn_unused result base64_to_binary(
  * @param length        the length of the input in bytes
  * @return number of base64 bytes
  */
-simdutf_warn_unused size_t base64_length_from_binary(
-    size_t length, base64_options options = base64_default) noexcept;
+inline simdutf_warn_unused simdutf_constexpr23 size_t base64_length_from_binary(
+    size_t length, base64_options options = base64_default) noexcept {
+  return scalar::base64::base64_length_from_binary(length, options);
+}
+
+/**
+ * Provide the base64 length in bytes given the length of a binary input,
+ * taking into account line breaks.
+ *
+ * @param length        the length of the input in bytes
+ * @param line_length   the length of lines, must be at least 4 (otherwise it is
+ * interpreted as 4),
+ * @return number of base64 bytes
+ */
+inline simdutf_warn_unused simdutf_constexpr23 size_t
+base64_length_from_binary_with_lines(
+    size_t length, base64_options options = base64_default,
+    size_t line_length = default_line_length) noexcept {
+  return scalar::base64::base64_length_from_binary_with_lines(length, options,
+                                                              line_length);
+}
 
 /**
  * Convert a binary input to a base64 output.
@@ -1433,13 +7241,70 @@ simdutf_warn_unused size_t base64_length_from_binary(
 size_t binary_to_base64(const char *input, size_t length, char *output,
                         base64_options options = base64_default) noexcept;
   #if SIMDUTF_SPAN
-simdutf_really_inline simdutf_warn_unused size_t
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t
 binary_to_base64(const detail::input_span_of_byte_like auto &input,
                  detail::output_span_of_byte_like auto &&binary_output,
                  base64_options options = base64_default) noexcept {
-  return binary_to_base64(
-      reinterpret_cast<const char *>(input.data()), input.size(),
-      reinterpret_cast<char *>(binary_output.data()), options);
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::tail_encode_base64(
+        binary_output.data(), input.data(), input.size(), options);
+  } else
+    #endif
+  {
+    return binary_to_base64(
+        reinterpret_cast<const char *>(input.data()), input.size(),
+        reinterpret_cast<char *>(binary_output.data()), options);
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Convert a binary input to a base64 output with line breaks.
+ *
+ * The default option (simdutf::base64_default) uses the characters `+` and `/`
+ * as part of its alphabet. Further, it adds padding (`=`) at the end of the
+ * output to ensure that the output length is a multiple of four.
+ *
+ * The URL option (simdutf::base64_url) uses the characters `-` and `_` as part
+ * of its alphabet. No padding is added at the end of the output.
+ *
+ * This function always succeeds.
+ *
+ * @param input         the binary to process
+ * @param length        the length of the input in bytes
+ * @param output        the pointer to a buffer that can hold the conversion
+ * result (should be at least base64_length_from_binary_with_lines(length,
+ * options, line_length) bytes long)
+ * @param line_length   the length of lines, must be at least 4 (otherwise it is
+ * interpreted as 4),
+ * @param options       the base64 options to use, can be base64_default or
+ * base64_url, is base64_default by default.
+ * @return number of written bytes, will be equal to
+ * base64_length_from_binary_with_lines(length, options)
+ */
+size_t
+binary_to_base64_with_lines(const char *input, size_t length, char *output,
+                            size_t line_length = simdutf::default_line_length,
+                            base64_options options = base64_default) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 size_t
+binary_to_base64_with_lines(
+    const detail::input_span_of_byte_like auto &input,
+    detail::output_span_of_byte_like auto &&binary_output,
+    size_t line_length = simdutf::default_line_length,
+    base64_options options = base64_default) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::tail_encode_base64_impl<true>(
+        binary_output.data(), input.data(), input.size(), options, line_length);
+  } else
+    #endif
+  {
+    return binary_to_base64_with_lines(
+        reinterpret_cast<const char *>(input.data()), input.size(),
+        reinterpret_cast<char *>(binary_output.data()), line_length, options);
+  }
 }
   #endif // SIMDUTF_SPAN
 
@@ -1562,32 +7427,197 @@ base64_to_binary(const char16_t *input, size_t length, char *output,
                  last_chunk_handling_options last_chunk_options =
                      last_chunk_handling_options::loose) noexcept;
   #if SIMDUTF_SPAN
-simdutf_really_inline simdutf_warn_unused result base64_to_binary(
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 result
+base64_to_binary(
+    std::span<const char16_t> input,
+    detail::output_span_of_byte_like auto &&binary_output,
+    base64_options options = base64_default,
+    last_chunk_handling_options last_chunk_options = loose) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::base64_to_binary_details_impl(
+        input.data(), input.size(), binary_output.data(), options,
+        last_chunk_options);
+  } else
+    #endif
+  {
+    return base64_to_binary(input.data(), input.size(),
+                            reinterpret_cast<char *>(binary_output.data()),
+                            options, last_chunk_options);
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Convert a base64 input to a binary output while returning more details
+ * than base64_to_binary.
+ *
+ * This function follows the WHATWG forgiving-base64 format, which means that it
+ * will ignore any ASCII spaces in the input. You may provide a padded input
+ * (with one or two equal signs at the end) or an unpadded input (without any
+ * equal signs at the end).
+ *
+ * See https://infra.spec.whatwg.org/#forgiving-base64-decode
+ *
+ * Unlike base64_to_binary, this function returns a full_result with both
+ * input_count and output_count, so you always know how much input was consumed
+ * and how much output was written. There are three cases where the input may
+ * not be fully consumed:
+ *
+ * 1. stop_before_partial: When last_chunk_options is set to
+ *    stop_before_partial, any incomplete 4-character group at the end of the
+ *    input is left unconsumed. This is useful for streaming/chunked decoding
+ *    where you can carry over the unconsumed input to the next chunk.
+ *
+ * 2. INVALID_BASE64_CHARACTER: The input contains a character that is not a
+ *    valid base64 character. In this case, input_count indicates where the
+ *    invalid character was found.
+ *
+ * 3. BASE64_INPUT_REMAINDER: When last_chunk_options is loose, the input
+ *    contains a number of base64 characters that, when divided by 4, leaves
+ *    a single remainder character (which cannot encode any bytes).
+ *
+ * You should call this function with a buffer that is at least
+ * maximal_binary_length_from_base64(input, length) bytes long. If you fail to
+ * provide that much space, the function may cause a buffer overflow.
+ *
+ * @param input         the base64 string to process
+ * @param length        the length of the string in bytes
+ * @param output        the pointer to a buffer that can hold the conversion
+ * result (should be at least maximal_binary_length_from_base64(input, length)
+ * bytes long).
+ * @param options       the base64 options to use, can be base64_default or
+ * base64_url, is base64_default by default.
+ * @param last_chunk_options the last chunk handling options,
+ * last_chunk_handling_options::loose by default
+ * but can also be last_chunk_handling_options::strict or
+ * last_chunk_handling_options::stop_before_partial.
+ * @return a full_result struct (of type simdutf::full_result containing the
+ * three fields error, input_count and output_count).
+ */
+simdutf_warn_unused full_result
+base64_to_binary_details(const char *input, size_t length, char *output,
+                         base64_options options = base64_default,
+                         last_chunk_handling_options last_chunk_options =
+                             last_chunk_handling_options::loose) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 full_result
+base64_to_binary_details(
+    const detail::input_span_of_byte_like auto &input,
+    detail::output_span_of_byte_like auto &&binary_output,
+    base64_options options = base64_default,
+    last_chunk_handling_options last_chunk_options = loose) noexcept {
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::base64_to_binary_details_impl(
+        input.data(), input.size(), binary_output.data(), options,
+        last_chunk_options);
+  } else
+    #endif
+  {
+    return base64_to_binary_details(
+        reinterpret_cast<const char *>(input.data()), input.size(),
+        reinterpret_cast<char *>(binary_output.data()), options,
+        last_chunk_options);
+  }
+}
+  #endif // SIMDUTF_SPAN
+
+/**
+ * Convert a base64 input to a binary output while returning more details
+ * than base64_to_binary.
+ *
+ * This function follows the WHATWG forgiving-base64 format, which means that it
+ * will ignore any ASCII spaces in the input. You may provide a padded input
+ * (with one or two equal signs at the end) or an unpadded input (without any
+ * equal signs at the end).
+ *
+ * See https://infra.spec.whatwg.org/#forgiving-base64-decode
+ *
+ * Unlike base64_to_binary, this function returns a full_result with both
+ * input_count and output_count, so you always know how much input was consumed
+ * and how much output was written. There are three cases where the input may
+ * not be fully consumed:
+ *
+ * 1. stop_before_partial: When last_chunk_options is set to
+ *    stop_before_partial, any incomplete 4-character group at the end of the
+ *    input is left unconsumed. This is useful for streaming/chunked decoding
+ *    where you can carry over the unconsumed input to the next chunk.
+ *
+ * 2. INVALID_BASE64_CHARACTER: The input contains a character that is not a
+ *    valid base64 character. In this case, input_count indicates where the
+ *    invalid character was found.
+ *
+ * 3. BASE64_INPUT_REMAINDER: When last_chunk_options is loose, the input
+ *    contains a number of base64 characters that, when divided by 4, leaves
+ *    a single remainder character (which cannot encode any bytes).
+ *
+ * You should call this function with a buffer that is at least
+ * maximal_binary_length_from_base64(input, length) bytes long. If you fail to
+ * provide that much space, the function may cause a buffer overflow.
+ *
+ * @param input         the base64 string to process, in ASCII stored as 16-bit
+ * units
+ * @param length        the length of the string in 16-bit units
+ * @param output        the pointer to a buffer that can hold the conversion
+ * result (should be at least maximal_binary_length_from_base64(input, length)
+ * bytes long).
+ * @param options       the base64 options to use, can be base64_default or
+ * base64_url, is base64_default by default.
+ * @param last_chunk_options the last chunk handling options,
+ * last_chunk_handling_options::loose by default
+ * but can also be last_chunk_handling_options::strict or
+ * last_chunk_handling_options::stop_before_partial.
+ * @return a full_result struct (of type simdutf::full_result containing the
+ * three fields error, input_count and output_count).
+ */
+simdutf_warn_unused full_result
+base64_to_binary_details(const char16_t *input, size_t length, char *output,
+                         base64_options options = base64_default,
+                         last_chunk_handling_options last_chunk_options =
+                             last_chunk_handling_options::loose) noexcept;
+  #if SIMDUTF_SPAN
+simdutf_really_inline simdutf_warn_unused simdutf_constexpr23 full_result
+base64_to_binary_details(
     std::span<const char16_t> input,
     detail::output_span_of_byte_like auto &&binary_output,
     base64_options options = base64_default,
     last_chunk_handling_options last_chunk_options = loose) noexcept {
-  return base64_to_binary(input.data(), input.size(),
-                          reinterpret_cast<char *>(binary_output.data()),
-                          options, last_chunk_options);
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    return scalar::base64::base64_to_binary_details_impl(
+        input.data(), input.size(), binary_output.data(), options,
+        last_chunk_options);
+  } else
+    #endif
+  {
+    return base64_to_binary_details(
+        input.data(), input.size(),
+        reinterpret_cast<char *>(binary_output.data()), options,
+        last_chunk_options);
+  }
 }
   #endif // SIMDUTF_SPAN
 
 /**
- * Check if a character is an ignorabl base64 character.
+ * Check if a character is an ignorable base64 character.
  * Checking a large input, character by character, is not computationally
  * efficient.
  *
  * @param input         the character to check
  * @param options       the base64 options to use, is base64_default by default.
- * @return true if the character is an ignorablee base64 character, false
+ * @return true if the character is an ignorable base64 character, false
  * otherwise.
  */
-simdutf_warn_unused bool
-base64_ignorable(char input, base64_options options = base64_default) noexcept;
-simdutf_warn_unused bool
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 bool
+base64_ignorable(char input, base64_options options = base64_default) noexcept {
+  return scalar::base64::is_ignorable(input, options);
+}
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 bool
 base64_ignorable(char16_t input,
-                 base64_options options = base64_default) noexcept;
+                 base64_options options = base64_default) noexcept {
+  return scalar::base64::is_ignorable(input, options);
+}
 
 /**
  * Check if a character is a valid base64 character.
@@ -1600,10 +7630,14 @@ base64_ignorable(char16_t input,
  * @param options       the base64 options to use, is base64_default by default.
  * @return true if the character is a base64 character, false otherwise.
  */
-simdutf_warn_unused bool
-base64_valid(char input, base64_options options = base64_default) noexcept;
-simdutf_warn_unused bool
-base64_valid(char16_t input, base64_options options = base64_default) noexcept;
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 bool
+base64_valid(char input, base64_options options = base64_default) noexcept {
+  return scalar::base64::is_base64(input, options);
+}
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 bool
+base64_valid(char16_t input, base64_options options = base64_default) noexcept {
+  return scalar::base64::is_base64(input, options);
+}
 
 /**
  * Check if a character is a valid base64 character or the padding character
@@ -1614,12 +7648,16 @@ base64_valid(char16_t input, base64_options options = base64_default) noexcept;
  * @param options       the base64 options to use, is base64_default by default.
  * @return true if the character is a base64 character, false otherwise.
  */
-simdutf_warn_unused bool
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 bool
 base64_valid_or_padding(char input,
-                        base64_options options = base64_default) noexcept;
-simdutf_warn_unused bool
+                        base64_options options = base64_default) noexcept {
+  return scalar::base64::is_base64_or_padding(input, options);
+}
+simdutf_warn_unused simdutf_really_inline simdutf_constexpr23 bool
 base64_valid_or_padding(char16_t input,
-                        base64_options options = base64_default) noexcept;
+                        base64_options options = base64_default) noexcept {
+  return scalar::base64::is_base64_or_padding(input, options);
+}
 
 /**
  * Convert a base64 input to a binary output.
@@ -1694,25 +7732,7 @@ base64_to_binary_safe(const char *input, size_t length, char *output,
                       last_chunk_handling_options last_chunk_options =
                           last_chunk_handling_options::loose,
                       bool decode_up_to_bad_char = false) noexcept;
-  #if SIMDUTF_SPAN
-/**
- * @brief span overload
- * @return a tuple of result and outlen
- */
-simdutf_really_inline simdutf_warn_unused std::tuple<result, std::size_t>
-base64_to_binary_safe(const detail::input_span_of_byte_like auto &input,
-                      detail::output_span_of_byte_like auto &&binary_output,
-                      base64_options options = base64_default,
-                      last_chunk_handling_options last_chunk_options = loose,
-                      bool decode_up_to_bad_char = false) noexcept {
-  size_t outlen = binary_output.size();
-  auto r = base64_to_binary_safe(
-      reinterpret_cast<const char *>(input.data()), input.size(),
-      reinterpret_cast<char *>(binary_output.data()), outlen, options,
-      last_chunk_options, decode_up_to_bad_char);
-  return {r, outlen};
-}
-  #endif // SIMDUTF_SPAN
+// the span overload has moved to the bottom of the file
 
 simdutf_warn_unused result
 base64_to_binary_safe(const char16_t *input, size_t length, char *output,
@@ -1720,25 +7740,7 @@ base64_to_binary_safe(const char16_t *input, size_t length, char *output,
                       last_chunk_handling_options last_chunk_options =
                           last_chunk_handling_options::loose,
                       bool decode_up_to_bad_char = false) noexcept;
-  #if SIMDUTF_SPAN
-/**
- * @brief span overload
- * @return a tuple of result and outlen
- */
-simdutf_really_inline simdutf_warn_unused std::tuple<result, std::size_t>
-base64_to_binary_safe(std::span<const char16_t> input,
-                      detail::output_span_of_byte_like auto &&binary_output,
-                      base64_options options = base64_default,
-                      last_chunk_handling_options last_chunk_options = loose,
-                      bool decode_up_to_bad_char = false) noexcept {
-  size_t outlen = binary_output.size();
-  auto r = base64_to_binary_safe(input.data(), input.size(),
-                                 reinterpret_cast<char *>(binary_output.data()),
-                                 outlen, options, last_chunk_options,
-                                 decode_up_to_bad_char);
-  return {r, outlen};
-}
-  #endif // SIMDUTF_SPAN
+  // span overload moved to bottom of file
 
   #if SIMDUTF_ATOMIC_REF
 /**
@@ -1832,21 +7834,6 @@ atomic_base64_to_binary_safe(
     #endif // SIMDUTF_SPAN
   #endif   // SIMDUTF_ATOMIC_REF
 
-/**
- * Find the first occurrence of a character in a string. If the character is
- * not found, return a pointer to the end of the string.
- * @param start        the start of the string
- * @param end          the end of the string
- * @param character    the character to find
- * @return a pointer to the first occurrence of the character in the string,
- * or a pointer to the end of the string if the character is not found.
- *
- */
-simdutf_warn_unused const char *find(const char *start, const char *end,
-                                     char character) noexcept;
-simdutf_warn_unused const char16_t *
-find(const char16_t *start, const char16_t *end, char16_t character) noexcept;
-
 /**
  * An implementation of simdutf for a particular CPU architecture.
  *
@@ -1865,7 +7852,7 @@ class implementation {
    *
    * @return the name of the implementation, e.g. "haswell", "westmere", "arm64"
    */
-  virtual std::string name() const { return std::string(_name); }
+  virtual std::string_view name() const noexcept { return _name; }
 
   /**
    * The description of this implementation.
@@ -1876,7 +7863,7 @@ class implementation {
    *
    * @return the name of the implementation, e.g. "haswell", "westmere", "arm64"
    */
-  virtual std::string description() const { return std::string(_description); }
+  virtual std::string_view description() const noexcept { return _description; }
 
   /**
    * The instruction sets this implementation is compiled against
@@ -1902,9 +7889,12 @@ class implementation {
 
   /**
    * Provide the maximal binary length in bytes given the base64 input.
-   * In general, if the input contains ASCII spaces, the result will be less
-   * than the maximum length. It is acceptable to pass invalid base64 strings
-   * but in such cases the result is implementation defined.
+   * As long as the input does not contain ignorable characters (e.g., ASCII
+   * spaces or linefeed characters), the result is exact. In particular, the
+   * function checks for padding characters.
+   *
+   * The function is fast (constant time). It checks up to two characters at
+   * the end of the string. The input is not otherwise validated or read..
    *
    * @param input         the base64 input to process
    * @param length        the length of the base64 input in bytes
@@ -1915,9 +7905,12 @@ class implementation {
 
   /**
    * Provide the maximal binary length in bytes given the base64 input.
-   * In general, if the input contains ASCII spaces, the result will be less
-   * than the maximum length. It is acceptable to pass invalid base64 strings
-   * but in such cases the result is implementation defined.
+   * As long as the input does not contain ignorable characters (e.g., ASCII
+   * spaces or linefeed characters), the result is exact. In particular, the
+   * function checks for padding characters.
+   *
+   * The function is fast (constant time). It checks up to two characters at
+   * the end of the string. The input is not otherwise validated or read.
    *
    * @param input         the base64 input to process, in ASCII stored as 16-bit
    * units
@@ -1927,6 +7920,38 @@ class implementation {
   simdutf_warn_unused size_t maximal_binary_length_from_base64(
       const char16_t *input, size_t length) const noexcept;
 
+  /**
+   * Compute the binary length from a base64 input with ASCII spaces.
+   * This function is useful for well-formed base64 inputs that may contain
+   * ASCII spaces (such as line breaks). For such inputs, the result is exact.
+   *
+   * The function counts non-whitespace characters (ASCII value > 0x20) and
+   * subtracts padding characters ('=') found at the end.
+   *
+   * @param input         the base64 input to process
+   * @param length        the length of the base64 input in bytes
+   * @return number of binary bytes
+   */
+  simdutf_warn_unused virtual size_t
+  binary_length_from_base64(const char *input, size_t length) const noexcept;
+
+  /**
+   * Compute the binary length from a base64 input with ASCII spaces.
+   * This function is useful for well-formed base64 inputs that may contain
+   * ASCII spaces (such as line breaks). For such inputs, the result is exact.
+   *
+   * The function counts non-whitespace characters (ASCII value > 0x20) and
+   * subtracts padding characters ('=') found at the end.
+   *
+   * @param input         the base64 input to process, in ASCII stored as 16-bit
+   * units
+   * @param length        the length of the base64 input in 16-bit units
+   * @return number of binary bytes
+   */
+  simdutf_warn_unused virtual size_t
+  binary_length_from_base64(const char16_t *input,
+                            size_t length) const noexcept;
+
   /**
    * Convert a base64 input to a binary output.
    *
@@ -2001,6 +8026,7 @@ class implementation {
       base64_options options = base64_default,
       last_chunk_handling_options last_chunk_options =
           last_chunk_handling_options::loose) const noexcept = 0;
+
   /**
    * Convert a base64 input to a binary output.
    *
@@ -2076,11 +8102,12 @@ class implementation {
       base64_options options = base64_default,
       last_chunk_handling_options last_chunk_options =
           last_chunk_handling_options::loose) const noexcept = 0;
+
   /**
    * Provide the base64 length in bytes given the length of a binary input.
    *
    * @param length        the length of the input in bytes
-   * @parem options       the base64 options to use, can be base64_default or
+   * @param options       the base64 options to use, can be base64_default or
    * base64_url, is base64_default by default.
    * @return number of base64 bytes
    */
@@ -2111,6 +8138,37 @@ class implementation {
   virtual size_t
   binary_to_base64(const char *input, size_t length, char *output,
                    base64_options options = base64_default) const noexcept = 0;
+
+  /**
+   * Convert a binary input to a base64 output with lines of given length.
+   * Lines are separated by a single linefeed character.
+   *
+   * The default option (simdutf::base64_default) uses the characters `+` and
+   * `/` as part of its alphabet. Further, it adds padding (`=`) at the end of
+   * the output to ensure that the output length is a multiple of four.
+   *
+   * The URL option (simdutf::base64_url) uses the characters `-` and `_` as
+   * part of its alphabet. No padding is added at the end of the output.
+   *
+   * This function always succeeds.
+   *
+   * @param input         the binary to process
+   * @param length        the length of the input in bytes
+   * @param output        the pointer to a buffer that can hold the conversion
+   * result (should be at least base64_length_from_binary_with_lines(length,
+   * options, line_length) bytes long)
+   * @param line_length   the length of each line, values smaller than 4 are
+   * interpreted as 4
+   * @param options       the base64 options to use, can be base64_default or
+   * base64_url, is base64_default by default.
+   * @return number of written bytes, will be equal to
+   * base64_length_from_binary_with_lines(length, options, line_length)
+   */
+  virtual size_t binary_to_base64_with_lines(
+      const char *input, size_t length, char *output,
+      size_t line_length = simdutf::default_line_length,
+      base64_options options = base64_default) const noexcept = 0;
+
   /**
    * Find the first occurrence of a character in a string. If the character is
    * not found, return a pointer to the end of the string.
@@ -2137,7 +8195,7 @@ class implementation {
 
   struct TestProcedure {
     // display name
-    std::string name;
+    std::string_view name;
 
     // procedure should return whether given test pass or not
     void (*procedure)(const implementation &);
@@ -2205,7 +8263,7 @@ class available_implementation_list {
    * @param name the implementation to find, e.g. "westmere", "haswell", "arm64"
    * @return the implementation, or nullptr if the parse failed.
    */
-  const implementation *operator[](const std::string &name) const noexcept {
+  const implementation *operator[](std::string_view name) const noexcept {
     for (const implementation *impl : *this) {
       if (impl->name() == name) {
         return impl;
@@ -2291,6 +8349,316 @@ get_active_implementation();
 
 } // namespace simdutf
 
+  // this header is not part of the public api
+/* begin file include/simdutf/base64_implementation.h */
+#ifndef SIMDUTF_BASE64_IMPLEMENTATION_H
+#define SIMDUTF_BASE64_IMPLEMENTATION_H
+
+// this is not part of the public api
+
+namespace simdutf {
+
+template <typename chartype>
+simdutf_warn_unused simdutf_constexpr23 result slow_base64_to_binary_safe_impl(
+    const chartype *input, size_t length, char *output, size_t &outlen,
+    base64_options options,
+    last_chunk_handling_options last_chunk_options) noexcept {
+  const bool ignore_garbage = (options & base64_default_accept_garbage) != 0;
+  auto ri = simdutf::scalar::base64::find_end(input, length, options);
+  size_t equallocation = ri.equallocation;
+  size_t equalsigns = ri.equalsigns;
+  length = ri.srclen;
+  size_t full_input_length = ri.full_input_length;
+  (void)full_input_length;
+  if (length == 0) {
+    outlen = 0;
+    if (!ignore_garbage && equalsigns > 0) {
+      return {INVALID_BASE64_CHARACTER, equallocation};
+    }
+    return {SUCCESS, 0};
+  }
+
+  // The parameters of base64_tail_decode_safe are:
+  // - dst: the output buffer
+  // - outlen: the size of the output buffer
+  // - srcr: the input buffer
+  // - length: the size of the input buffer
+  // - padded_characters: the number of padding characters
+  // - options: the options for the base64 decoder
+  // - last_chunk_options: the options for the last chunk
+  // The function will return the number of bytes written to the output buffer
+  // and the number of bytes read from the input buffer.
+  // The function will also return an error code if the input buffer is not
+  // valid base64.
+  full_result r = scalar::base64::base64_tail_decode_safe(
+      output, outlen, input, length, equalsigns, options, last_chunk_options);
+  r = scalar::base64::patch_tail_result(r, 0, 0, equallocation,
+                                        full_input_length, last_chunk_options);
+  outlen = r.output_count;
+  if (!is_partial(last_chunk_options) && r.error == error_code::SUCCESS &&
+      equalsigns > 0) {
+    // additional checks
+    if ((outlen % 3 == 0) || ((outlen % 3) + 1 + equalsigns != 4)) {
+      r.error = error_code::INVALID_BASE64_CHARACTER;
+    }
+  }
+  return {r.error, r.input_count}; // we cannot return r itself because it gets
+                                   // converted to error/output_count
+}
+
+template <typename chartype>
+simdutf_warn_unused simdutf_constexpr23 result base64_to_binary_safe_impl(
+    const chartype *input, size_t length, char *output, size_t &outlen,
+    base64_options options,
+    last_chunk_handling_options last_chunk_handling_options,
+    bool decode_up_to_bad_char) noexcept {
+  static_assert(std::is_same<chartype, char>::value ||
+                    std::is_same<chartype, char16_t>::value,
+                "Only char and char16_t are supported.");
+  size_t remaining_input_length = length;
+  size_t remaining_output_length = outlen;
+  size_t input_position = 0;
+  size_t output_position = 0;
+
+  // We also do a first pass using the fast path to decode as much as possible
+  size_t safe_input = (std::min)(
+      remaining_input_length,
+      base64_length_from_binary(remaining_output_length / 3 * 3, options));
+  bool done_with_partial = (safe_input == remaining_input_length);
+  simdutf::full_result r;
+
+#if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    r = scalar::base64::base64_to_binary_details_impl(
+        input + input_position, safe_input, output + output_position, options,
+        done_with_partial
+            ? last_chunk_handling_options
+            : simdutf::last_chunk_handling_options::only_full_chunks);
+  } else
+#endif
+  {
+    r = get_active_implementation()->base64_to_binary_details(
+        input + input_position, safe_input, output + output_position, options,
+        done_with_partial
+            ? last_chunk_handling_options
+            : simdutf::last_chunk_handling_options::only_full_chunks);
+  }
+  simdutf_log_assert(r.input_count <= safe_input,
+                     "You should not read more than safe_input");
+  simdutf_log_assert(r.output_count <= remaining_output_length,
+                     "You should not write more than remaining_output_length");
+  // Technically redundant, but we want to be explicit about it.
+  input_position += r.input_count;
+  output_position += r.output_count;
+  remaining_input_length -= r.input_count;
+  remaining_output_length -= r.output_count;
+  if (r.error != simdutf::error_code::SUCCESS) {
+    // There is an error. We return.
+    if (decode_up_to_bad_char &&
+        r.error == error_code::INVALID_BASE64_CHARACTER) {
+      return slow_base64_to_binary_safe_impl(
+          input, length, output, outlen, options, last_chunk_handling_options);
+    }
+    outlen = output_position;
+    return {r.error, input_position};
+  }
+
+  if (done_with_partial) {
+    // We are done. We have decoded everything.
+    outlen = output_position;
+    return {simdutf::error_code::SUCCESS, input_position};
+  }
+  // We have decoded some data, but we still have some data to decode.
+  // We need to decode the rest of the input buffer.
+  r = simdutf::scalar::base64::base64_to_binary_details_safe_impl(
+      input + input_position, remaining_input_length, output + output_position,
+      remaining_output_length, options, last_chunk_handling_options);
+  input_position += r.input_count;
+  output_position += r.output_count;
+  remaining_input_length -= r.input_count;
+  remaining_output_length -= r.output_count;
+
+  if (r.error != simdutf::error_code::SUCCESS) {
+    // There is an error. We return.
+    if (decode_up_to_bad_char &&
+        r.error == error_code::INVALID_BASE64_CHARACTER) {
+      return slow_base64_to_binary_safe_impl(
+          input, length, output, outlen, options, last_chunk_handling_options);
+    }
+    outlen = output_position;
+    return {r.error, input_position};
+  }
+  if (input_position < length) {
+    // We cannot process the entire input in one go, so we need to
+    // process it in two steps: first the fast path, then the slow path.
+    // In some cases, the processing might 'eat up' trailing ignorable
+    // characters in the fast path, but that can be a problem.
+    // suppose we have just white space followed by a single base64 character.
+    // If we first process the white space with the fast path, it will
+    // eat all of it. But, by the JavaScript standard, we should consume
+    // no character. See
+    // https://tc39.es/proposal-arraybuffer-base64/spec/#sec-frombase64
+    while (input_position > 0 &&
+           base64_ignorable(input[input_position - 1], options)) {
+      input_position--;
+    }
+  }
+  outlen = output_position;
+  return {simdutf::error_code::SUCCESS, input_position};
+}
+
+} // namespace simdutf
+#endif // SIMDUTF_BASE64_IMPLEMENTATION_H
+/* end file include/simdutf/base64_implementation.h */
+
+namespace simdutf {
+  #if SIMDUTF_SPAN
+/**
+ * @brief span overload
+ * @return a tuple of result and outlen
+ */
+simdutf_really_inline
+    simdutf_constexpr23 simdutf_warn_unused std::tuple<result, std::size_t>
+    base64_to_binary_safe(
+        const detail::input_span_of_byte_like auto &input,
+        detail::output_span_of_byte_like auto &&binary_output,
+        base64_options options = base64_default,
+        last_chunk_handling_options last_chunk_options = loose,
+        bool decode_up_to_bad_char = false) noexcept {
+  size_t outlen = binary_output.size();
+    #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    using CInput = std::decay_t<decltype(*input.data())>;
+    static_assert(std::is_same_v<CInput, char>,
+                  "sorry, the constexpr implementation is for now limited to "
+                  "input of type char");
+    using COutput = std::decay_t<decltype(*binary_output.data())>;
+    static_assert(std::is_same_v<COutput, char>,
+                  "sorry, the constexpr implementation is for now limited to "
+                  "output of type char");
+    auto r = base64_to_binary_safe_impl(
+        input.data(), input.size(), binary_output.data(), outlen, options,
+        last_chunk_options, decode_up_to_bad_char);
+    return {r, outlen};
+  } else
+    #endif
+  {
+    auto r = base64_to_binary_safe_impl<char>(
+        reinterpret_cast<const char *>(input.data()), input.size(),
+        reinterpret_cast<char *>(binary_output.data()), outlen, options,
+        last_chunk_options, decode_up_to_bad_char);
+    return {r, outlen};
+  }
+}
+
+    #if SIMDUTF_SPAN
+/**
+ * @brief span overload
+ * @return a tuple of result and outlen
+ */
+simdutf_really_inline
+    simdutf_warn_unused simdutf_constexpr23 std::tuple<result, std::size_t>
+    base64_to_binary_safe(
+        std::span<const char16_t> input,
+        detail::output_span_of_byte_like auto &&binary_output,
+        base64_options options = base64_default,
+        last_chunk_handling_options last_chunk_options = loose,
+        bool decode_up_to_bad_char = false) noexcept {
+  size_t outlen = binary_output.size();
+      #if SIMDUTF_CPLUSPLUS23
+  if consteval {
+    auto r = base64_to_binary_safe_impl(
+        input.data(), input.size(), binary_output.data(), outlen, options,
+        last_chunk_options, decode_up_to_bad_char);
+    return {r, outlen};
+  } else
+      #endif
+  {
+    auto r = base64_to_binary_safe(
+        input.data(), input.size(),
+        reinterpret_cast<char *>(binary_output.data()), outlen, options,
+        last_chunk_options, decode_up_to_bad_char);
+    return {r, outlen};
+  }
+}
+    #endif // SIMDUTF_SPAN
+
+  #endif // SIMDUTF_SPAN
+} // namespace simdutf
+
+#if SIMDUTF_CPLUSPLUS23 && SIMDUTF_FEATURE_BASE64
+
+namespace simdutf {
+namespace literals {
+
+namespace detail {
+
+// the detail namespace is not part of the public api
+
+template <std::size_t N> struct base64_literal_helper {
+  std::array<char, N - 1> storage{};
+  static constexpr std::size_t size() noexcept { return N - 1; }
+  consteval base64_literal_helper(const char (&str)[N]) {
+    for (std::size_t i = 0; i < size(); i++) {
+      storage[i] = str[i];
+    }
+  }
+};
+
+template <std::size_t InputLen> struct base64_decode_result {
+  static constexpr std::size_t max_out = (InputLen + 3) / 4 * 3;
+  std::array<char, max_out> buffer{};
+  std::size_t output_count{};
+};
+
+template <std::size_t InputLen>
+consteval auto base64_decode_literal(const char *str) {
+  base64_decode_result<InputLen> result{};
+  auto r = scalar::base64::base64_to_binary_details_impl(
+      str, InputLen, result.buffer.data(), base64_default, loose);
+  if (r.error != error_code::SUCCESS) {
+  #if __cpp_lib_unreachable >= 202202L
+    std::unreachable(); // invalid base64 input in _base64 literal
+  #else
+    // workaround for older stdlib
+    throw "invalid base64 input in _base64 literal";
+  #endif
+  }
+  result.output_count = r.output_count;
+  return result;
+}
+
+template <base64_literal_helper a> consteval auto base64_make_array() {
+  constexpr auto decoded = base64_decode_literal<a.size()>(a.storage.data());
+  std::array<char, decoded.output_count> ret{};
+  for (std::size_t i = 0; i < decoded.output_count; i++) {
+    ret[i] = decoded.buffer[i];
+  }
+  return ret;
+}
+
+} // namespace detail
+
+/**
+ * User-defined literal for compile-time base64 decoding.
+ *
+ * Usage:
+ *   using namespace simdutf::literals;
+ *   constexpr auto decoded = "SGVsbG8gV29ybGQh"_base64;
+ *   // decoded is a std::array<char, 12> containing "Hello World!"
+ *
+ * The input must be valid base64. Whitepace is allowed and ignored.
+ * A compilation error occurs if the input is invalid.
+ */
+template <detail::base64_literal_helper a> consteval auto operator""_base64() {
+  return detail::base64_make_array<a>();
+}
+
+} // namespace literals
+} // namespace simdutf
+
+#endif // SIMDUTF_CPLUSPLUS23 && SIMDUTF_FEATURE_BASE64
+
 #endif // SIMDUTF_IMPLEMENTATION_H
 /* end file include/simdutf/implementation.h */
 
diff --git a/example/Gemfile.lock b/example/Gemfile.lock
index f5fa9e6..4ab57d2 100644
--- a/example/Gemfile.lock
+++ b/example/Gemfile.lock
@@ -5,18 +5,12 @@ GEM
       base64
       nkf
       rexml
-    activesupport (7.2.2.2)
-      base64
-      benchmark (>= 0.3)
-      bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.3.1)
-      connection_pool (>= 2.2.5)
-      drb
+    activesupport (6.1.7.10)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
-      logger (>= 1.4.2)
       minitest (>= 5.1)
-      securerandom (>= 0.3)
-      tzinfo (~> 2.0, >= 2.0.5)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
     algoliasearch (1.27.5)
@@ -66,8 +60,6 @@ GEM
     cocoapods-try (1.2.0)
     colored2 (3.1.2)
     concurrent-ruby (1.3.3)
-    connection_pool (2.5.4)
-    drb (2.2.3)
     escape (0.0.4)
     ethon (0.15.0)
       ffi (>= 1.15.0)
@@ -79,9 +71,9 @@ GEM
       mutex_m
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
-    json (2.15.0)
+    json (2.7.6)
     logger (1.7.0)
-    minitest (5.25.5)
+    minitest (5.25.4)
     molinillo (0.8.0)
     mutex_m (0.3.0)
     nanaimo (0.3.0)
@@ -91,7 +83,6 @@ GEM
     public_suffix (4.0.7)
     rexml (3.4.4)
     ruby-macho (2.5.1)
-    securerandom (0.4.1)
     typhoeus (1.5.0)
       ethon (>= 0.9.0, < 0.16.0)
     tzinfo (2.0.6)
@@ -103,6 +94,7 @@ GEM
       colored2 (~> 3.1)
       nanaimo (~> 0.3.0)
       rexml (>= 3.3.6, < 4.0)
+    zeitwerk (2.6.18)
 
 PLATFORMS
   ruby
diff --git a/example/ios/NitroBase64Example.xcodeproj/project.pbxproj b/example/ios/NitroBase64Example.xcodeproj/project.pbxproj
index 0444ca0..8cd2c4c 100644
--- a/example/ios/NitroBase64Example.xcodeproj/project.pbxproj
+++ b/example/ios/NitroBase64Example.xcodeproj/project.pbxproj
@@ -7,23 +7,23 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		0C80B921A6F3F58F76C31292 /* libPods-NitroBase64Example.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5DCACB8F33CDC322A6C60F78 /* libPods-NitroBase64Example.a */; };
 		13B07FBF1A68108700A75B9A /* Images.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB51A68108700A75B9A /* Images.xcassets */; };
 		761780ED2CA45674006654EE /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 761780EC2CA45674006654EE /* AppDelegate.swift */; };
 		81AB9BB82411601600AC10FF /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */; };
 		BA8731FA8F4AE30FD34E383A /* PrivacyInfo.xcprivacy in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */; };
+		D891FF4993729C4A84C2F7E9 /* libPods-NitroBase64Example.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 098BA51963414FC1C9E6DB12 /* libPods-NitroBase64Example.a */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
+		098BA51963414FC1C9E6DB12 /* libPods-NitroBase64Example.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-NitroBase64Example.a"; sourceTree = BUILT_PRODUCTS_DIR; };
 		13B07F961A680F5B00A75B9A /* NitroBase64Example.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = NitroBase64Example.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = NitroBase64Example/Images.xcassets; sourceTree = "<group>"; };
 		13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = NitroBase64Example/Info.plist; sourceTree = "<group>"; };
 		13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = PrivacyInfo.xcprivacy; path = NitroBase64Example/PrivacyInfo.xcprivacy; sourceTree = "<group>"; };
-		3B4392A12AC88292D35C810B /* Pods-NitroBase64Example.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.debug.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.debug.xcconfig"; sourceTree = "<group>"; };
-		5709B34CF0A7D63546082F79 /* Pods-NitroBase64Example.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.release.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.release.xcconfig"; sourceTree = "<group>"; };
-		5DCACB8F33CDC322A6C60F78 /* libPods-NitroBase64Example.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-NitroBase64Example.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+		66E9F03C53D7017FE9545A1B /* Pods-NitroBase64Example.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.release.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.release.xcconfig"; sourceTree = "<group>"; };
 		761780EC2CA45674006654EE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = AppDelegate.swift; path = NitroBase64Example/AppDelegate.swift; sourceTree = "<group>"; };
 		81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; name = LaunchScreen.storyboard; path = NitroBase64Example/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		DAACC79F12F190ED23DE45D7 /* Pods-NitroBase64Example.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.debug.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.debug.xcconfig"; sourceTree = "<group>"; };
 		ED297162215061F000B7C4FE /* JavaScriptCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = JavaScriptCore.framework; path = System/Library/Frameworks/JavaScriptCore.framework; sourceTree = SDKROOT; };
 /* End PBXFileReference section */
 
@@ -32,7 +32,7 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				0C80B921A6F3F58F76C31292 /* libPods-NitroBase64Example.a in Frameworks */,
+				D891FF4993729C4A84C2F7E9 /* libPods-NitroBase64Example.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -55,7 +55,7 @@
 			isa = PBXGroup;
 			children = (
 				ED297162215061F000B7C4FE /* JavaScriptCore.framework */,
-				5DCACB8F33CDC322A6C60F78 /* libPods-NitroBase64Example.a */,
+				098BA51963414FC1C9E6DB12 /* libPods-NitroBase64Example.a */,
 			);
 			name = Frameworks;
 			sourceTree = "<group>";
@@ -92,8 +92,8 @@
 		BBD78D7AC51CEA395F1C20DB /* Pods */ = {
 			isa = PBXGroup;
 			children = (
-				3B4392A12AC88292D35C810B /* Pods-NitroBase64Example.debug.xcconfig */,
-				5709B34CF0A7D63546082F79 /* Pods-NitroBase64Example.release.xcconfig */,
+				DAACC79F12F190ED23DE45D7 /* Pods-NitroBase64Example.debug.xcconfig */,
+				66E9F03C53D7017FE9545A1B /* Pods-NitroBase64Example.release.xcconfig */,
 			);
 			path = Pods;
 			sourceTree = "<group>";
@@ -105,13 +105,13 @@
 			isa = PBXNativeTarget;
 			buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "NitroBase64Example" */;
 			buildPhases = (
-				C38B50BA6285516D6DCD4F65 /* [CP] Check Pods Manifest.lock */,
+				698DAD2D36C86EE227AD3CC1 /* [CP] Check Pods Manifest.lock */,
 				13B07F871A680F5B00A75B9A /* Sources */,
 				13B07F8C1A680F5B00A75B9A /* Frameworks */,
 				13B07F8E1A680F5B00A75B9A /* Resources */,
 				00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */,
-				00EEFC60759A1932668264C0 /* [CP] Embed Pods Frameworks */,
-				E235C05ADACE081382539298 /* [CP] Copy Pods Resources */,
+				9E13E8199B99474DE1C693E0 /* [CP] Embed Pods Frameworks */,
+				65F550C0311E7C54C50B866B /* [CP] Copy Pods Resources */,
 			);
 			buildRules = (
 			);
@@ -183,24 +183,24 @@
 			shellPath = /bin/sh;
 			shellScript = "set -e\n\nWITH_ENVIRONMENT=\"$REACT_NATIVE_PATH/scripts/xcode/with-environment.sh\"\nREACT_NATIVE_XCODE=\"$REACT_NATIVE_PATH/scripts/react-native-xcode.sh\"\n\n/bin/sh -c \"$WITH_ENVIRONMENT $REACT_NATIVE_XCODE\"\n";
 		};
-		00EEFC60759A1932668264C0 /* [CP] Embed Pods Frameworks */ = {
+		65F550C0311E7C54C50B866B /* [CP] Copy Pods Resources */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-input-files.xcfilelist",
+				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources-${CONFIGURATION}-input-files.xcfilelist",
 			);
-			name = "[CP] Embed Pods Frameworks";
+			name = "[CP] Copy Pods Resources";
 			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-output-files.xcfilelist",
+				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources-${CONFIGURATION}-output-files.xcfilelist",
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks.sh\"\n";
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources.sh\"\n";
 			showEnvVarsInLog = 0;
 		};
-		C38B50BA6285516D6DCD4F65 /* [CP] Check Pods Manifest.lock */ = {
+		698DAD2D36C86EE227AD3CC1 /* [CP] Check Pods Manifest.lock */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
@@ -222,21 +222,21 @@
 			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
 			showEnvVarsInLog = 0;
 		};
-		E235C05ADACE081382539298 /* [CP] Copy Pods Resources */ = {
+		9E13E8199B99474DE1C693E0 /* [CP] Embed Pods Frameworks */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources-${CONFIGURATION}-input-files.xcfilelist",
+				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-input-files.xcfilelist",
 			);
-			name = "[CP] Copy Pods Resources";
+			name = "[CP] Embed Pods Frameworks";
 			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources-${CONFIGURATION}-output-files.xcfilelist",
+				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-output-files.xcfilelist",
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources.sh\"\n";
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks.sh\"\n";
 			showEnvVarsInLog = 0;
 		};
 /* End PBXShellScriptBuildPhase section */
@@ -255,11 +255,12 @@
 /* Begin XCBuildConfiguration section */
 		13B07F941A680F5B00A75B9A /* Debug */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = 3B4392A12AC88292D35C810B /* Pods-NitroBase64Example.debug.xcconfig */;
+			baseConfigurationReference = DAACC79F12F190ED23DE45D7 /* Pods-NitroBase64Example.debug.xcconfig */;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
 				CURRENT_PROJECT_VERSION = 1;
+				DEVELOPMENT_TEAM = 4QDQZA9V92;
 				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = NitroBase64Example/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 16.6;
@@ -283,11 +284,12 @@
 		};
 		13B07F951A680F5B00A75B9A /* Release */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = 5709B34CF0A7D63546082F79 /* Pods-NitroBase64Example.release.xcconfig */;
+			baseConfigurationReference = 66E9F03C53D7017FE9545A1B /* Pods-NitroBase64Example.release.xcconfig */;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
 				CURRENT_PROJECT_VERSION = 1;
+				DEVELOPMENT_TEAM = 4QDQZA9V92;
 				INFOPLIST_FILE = NitroBase64Example/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 16.6;
 				LD_RUNPATH_SEARCH_PATHS = (
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index df8655d..217f83b 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -8,7 +8,7 @@ PODS:
   - hermes-engine (0.81.1):
     - hermes-engine/Pre-built (= 0.81.1)
   - hermes-engine/Pre-built (0.81.1)
-  - NitroBase64 (0.8.0):
+  - NitroBase64 (0.8.2):
     - boost
     - DoubleConversion
     - fast_float
@@ -38,7 +38,7 @@ PODS:
     - ReactCommon/turbomodule/core
     - SocketRocket
     - Yoga
-  - NitroModules (0.29.8):
+  - NitroModules (0.35.6):
     - boost
     - DoubleConversion
     - fast_float
@@ -1807,8 +1807,34 @@ PODS:
     - React-RCTFBReactNativeSpec
     - ReactCommon/turbomodule/core
     - SocketRocket
-  - react-native-quick-base64 (2.2.2):
+  - react-native-quick-base64 (3.0.0):
+    - boost
+    - DoubleConversion
+    - fast_float
+    - fmt
+    - glog
+    - hermes-engine
+    - RCT-Folly
+    - RCT-Folly/Fabric
+    - RCTRequired
+    - RCTTypeSafety
     - React-Core
+    - React-debug
+    - React-Fabric
+    - React-featureflags
+    - React-graphics
+    - React-ImageManager
+    - React-jsi
+    - React-NativeModulesApple
+    - React-RCTFabric
+    - React-renderercss
+    - React-rendererdebug
+    - React-utils
+    - ReactCodegen
+    - ReactCommon/turbomodule/bridging
+    - ReactCommon/turbomodule/core
+    - SocketRocket
+    - Yoga
   - react-native-safe-area-context (5.6.1):
     - boost
     - DoubleConversion
@@ -2648,8 +2674,8 @@ SPEC CHECKSUMS:
   fmt: a40bb5bd0294ea969aaaba240a927bd33d878cdd
   glog: 5683914934d5b6e4240e497e0f4a3b42d1854183
   hermes-engine: 4f8246b1f6d79f625e0d99472d1f3a71da4d28ca
-  NitroBase64: a902e6a58f53c5854d5fcfe1e8db4a29f89c2468
-  NitroModules: 808eee1dfaf75b2c5a63ea3608cb651cc7d13687
+  NitroBase64: e9d09ea94a839528b94a43d3c500ad1405c8a413
+  NitroModules: 70e2ff77a0b718e47d5bccd837fefe8a9aa20f50
   RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
   RCTDeprecation: c4b9e2fd0ab200e3af72b013ed6113187c607077
   RCTRequired: e97dd5dafc1db8094e63bc5031e0371f092ae92a
@@ -2683,7 +2709,7 @@ SPEC CHECKSUMS:
   React-logger: 7aef4d74123e5e3d267e5af1fbf5135b5a0d8381
   React-Mapbuffer: 91e0eab42a6ae7f3e34091a126d70fc53bd3823e
   React-microtasksnativemodule: 1ead4fe154df3b1ba34b5a9e35ef3c4bdfa72ccb
-  react-native-quick-base64: 6568199bb2ac8e72ecdfdc73a230fbc5c1d3aac4
+  react-native-quick-base64: e5eea0a73474108a7b80e33ce2c004a414649da2
   react-native-safe-area-context: c6e2edd1c1da07bdce287fa9d9e60c5f7b514616
   React-NativeModulesApple: eff2eba56030eb0d107b1642b8f853bc36a833ac
   React-oscompat: b12c633e9c00f1f99467b1e0e0b8038895dae436
diff --git a/example/package.json b/example/package.json
index 31912f2..30bc9ad 100644
--- a/example/package.json
+++ b/example/package.json
@@ -13,8 +13,8 @@
     "@react-native/new-app-screen": "0.81.1",
     "react": "19.1.0",
     "react-native": "0.81.1",
-    "react-native-nitro-modules": "^0.29.8",
-    "react-native-quick-base64": "^2.2.2",
+    "react-native-nitro-modules": "^0.35.6",
+    "react-native-quick-base64": "^3.0.0",
     "react-native-safe-area-context": "^5.5.2"
   },
   "devDependencies": {
diff --git a/example/src/Benchmark.tsx b/example/src/Benchmark.tsx
index 0bfe45d..764e943 100644
--- a/example/src/Benchmark.tsx
+++ b/example/src/Benchmark.tsx
@@ -38,7 +38,7 @@ const NitroBase64Demo = () => {
     try {
       // First encode to get valid base64
       const encoded = encode(inputText, urlSafeMode);
-      const result = decode(encoded, urlSafeMode);
+      const result = decode(encoded);
       logResult(`Nitro Decode (urlSafe: ${urlSafeMode})`, result);
       logResult('Round Trip Success', `${result === inputText ? 'YES' : 'NO'}`);
       Alert.alert(
@@ -57,14 +57,14 @@ const NitroBase64Demo = () => {
       const nitroEncoded = encode(inputText, false);
       logResult('Nitro encode()', nitroEncoded);
 
-      const nitroDecoded = decode(nitroEncoded, false);
+      const nitroDecoded = decode(nitroEncoded);
       logResult('Nitro decode()', nitroDecoded);
 
       // Test URL-safe version
       const nitroUrlSafe = encode(inputText, true);
       logResult('Nitro URL-safe encode()', nitroUrlSafe);
 
-      const nitroUrlSafeDecoded = decode(nitroUrlSafe, true);
+      const nitroUrlSafeDecoded = decode(nitroUrlSafe);
       logResult('Nitro URL-safe decode()', nitroUrlSafeDecoded);
 
       // Test if they match
@@ -101,7 +101,7 @@ const NitroBase64Demo = () => {
     testCases.forEach((testCase) => {
       try {
         const encoded = encode(testCase.data, urlSafeMode);
-        const decoded = decode(encoded, urlSafeMode);
+        const decoded = decode(encoded);
         const success = decoded === testCase.data;
         if (success) passCount++;
         logResult(
@@ -128,7 +128,7 @@ const NitroBase64Demo = () => {
 
       try {
         const encoded = encode(largeText, urlSafeMode);
-        const decoded = decode(encoded, urlSafeMode);
+        const decoded = decode(encoded);
         const endTime = Date.now();
         const duration = endTime - startTime;
 
diff --git a/example/src/Benchmark2.tsx b/example/src/Benchmark2.tsx
index 9d4a7e3..9c330b4 100644
--- a/example/src/Benchmark2.tsx
+++ b/example/src/Benchmark2.tsx
@@ -1,258 +1,292 @@
-/* global performance, atob, btoa */
-import jsBase64 from 'base64-js';
+import {
+  fromByteArray as quickFromByteArray,
+  toByteArray as quickToByteArray,
+} from 'react-native-quick-base64';
 import { useState } from 'react';
 import { Platform, Pressable, StyleSheet, Text, View } from 'react-native';
-import { decode, encode } from 'react-native-nitro-base64';
+import {
+  decode,
+  decodeBuffer,
+  encode,
+  encodeBuffer,
+  fromByteArray,
+  toByteArray,
+} from 'react-native-nitro-base64';
 import { data as largeData } from './image-large.json';
 import { data } from './image.json';
-const sleep = (t: number) => new Promise((resolve) => setTimeout(resolve, t));
 
-const round = (num: number, decimalPlaces = 0): string => {
-  return num.toFixed(decimalPlaces);
+declare const performance: { now(): number };
+declare function atob(data: string): string;
+declare function btoa(data: string): string;
+
+const sleep = (t: number) =>
+  new Promise<void>((resolve) => setTimeout(resolve, t));
+const round = (num: number, decimalPlaces = 0): string =>
+  num.toFixed(decimalPlaces);
+const speedup = (ms: number, base: number) => {
+  if (!ms || !base || base <= 0) return '';
+  const ratio = base / ms;
+  if (ratio >= 1) return `(${round(ratio, 2)}x faster)`;
+  return `(${round(1 / ratio, 2)}x slower)`;
 };
 
 const Benchmarks2 = () => {
-  const [processingJSBase64, setProcessingJSBase64] = useState<boolean>(false);
-  const [jsBase64Result, setJSBase64Result] = useState<number>(0);
-  const [processingNativeBase64, setProcessingNativeBase64] =
-    useState<boolean>(false);
-  const [nativeBase64Result, setNativeBase64Result] = useState<number>(0);
-  const [processingObjcBase64, setProcessingObjcBase64] =
-    useState<boolean>(false);
-  const [objcBase64Result, setObjcBase64Result] = useState<number>(0);
-  const [processingAtobBtoa, setProcessingAtobBtoa] = useState<boolean>(false);
-  const [atobBtoaResult, setAtobBtoaResult] = useState<number>(0);
-  const [processingAtobBtoaLarge, setProcessingAtobBtoaLarge] =
-    useState<boolean>(false);
-  const [atobBtoaLargeResult, setAtobBtoaLargeResult] = useState<number>(0);
-  const [processingJSBase64Large, setProcessingJSBase64Large] =
-    useState<boolean>(false);
-  const [jsBase64LargeResult, setJSBase64LargeResult] = useState<number>(0);
-
-  const handleNativeBase64Press = async () => {
-    setProcessingNativeBase64(true);
-    let dataToProcess = data;
-    await sleep(1);
-    const startTime = performance.now();
+  // Nitro string (small / large)
+  const [nitroResult, setNitroResult] = useState(0);
+  const [nitroLargeResult, setNitroLargeResult] = useState(0);
 
-    for (let iter = 0; iter < 30; iter++) {
-      const decoded = encode(dataToProcess);
-      dataToProcess = decode(decoded);
-      if (dataToProcess !== data) {
-        throw new Error('Data does not match');
-      }
-    }
-    const finishedTime = performance.now();
-    console.log(
-      'Nitro C++ done! took',
-      finishedTime - startTime,
-      'milliseconds'
-    );
-    setNativeBase64Result(finishedTime - startTime);
-    setProcessingNativeBase64(false);
-  };
+  // quick-base64 (small / large)
+  const [quickResult, setQuickResult] = useState(0);
+  const [quickLargeResult, setQuickLargeResult] = useState(0);
 
-  const handleJSBase64Press = async () => {
-    setProcessingJSBase64(true);
-    let dataToProcess = data;
-    await sleep(1);
-    const startTime = performance.now();
+  // atob/btoa (small / large)
+  const [atobResult, setAtobResult] = useState(0);
+  const [atobLargeResult, setAtobLargeResult] = useState(0);
+
+  // decodeBuffer (small / large)
+  const [decodeBufferResult, setDecodeBufferResult] = useState(0);
+  const [decodeBufferLargeResult, setDecodeBufferLargeResult] = useState(0);
+
+  // encodeBuffer (small / large)
+  const [encodeBufferResult, setEncodeBufferResult] = useState(0);
+  const [encodeBufferLargeResult, setEncodeBufferLargeResult] = useState(0);
 
-    for (let iter = 0; iter < 30; iter++) {
-      const decoded = jsBase64.toByteArray(dataToProcess);
-      dataToProcess = jsBase64.fromByteArray(decoded);
+  // fromByteArray / toByteArray (small / large)
+  const [fromByteArrayResult, setFromByteArrayResult] = useState(0);
+  const [fromByteArrayLargeResult, setFromByteArrayLargeResult] = useState(0);
+  const [toByteArrayResult, setToByteArrayResult] = useState(0);
+  const [toByteArrayLargeResult, setToByteArrayLargeResult] = useState(0);
+
+  const [processing, setProcessing] = useState(false);
+
+  // ── Nitro string ──────────────────────────────────────────────────────────
+
+  const runNitro = async (src: string): Promise<number> => {
+    let d = src;
+    await sleep(1);
+    const t = performance.now();
+    for (let i = 0; i < 30; i++) {
+      const enc = encode(d);
+      d = decode(enc);
     }
-    const finishedTime = performance.now();
-    console.log(
-      'base64-js done! took',
-      finishedTime - startTime,
-      'milliseconds'
-    );
-    setJSBase64Result(finishedTime - startTime);
-    setProcessingJSBase64(false);
+    return performance.now() - t;
   };
 
-  // atob/btoa benchmark (native browser API) - Small image
-  const handleAtobBtoaPress = async () => {
-    setProcessingAtobBtoa(true);
-    let dataToProcess = data;
-    await sleep(1);
-    const startTime = performance.now();
+  // ── quick-base64 ──────────────────────────────────────────────────────────
 
-    try {
-      for (let iter = 0; iter < 30; iter++) {
-        // btoa expects a binary string, atob returns a binary string
-        const decoded = atob(dataToProcess);
-        dataToProcess = btoa(decoded);
-      }
-      const finishedTime = performance.now();
-      console.log(
-        'atob/btoa done! took',
-        finishedTime - startTime,
-        'milliseconds'
-      );
-      setAtobBtoaResult(finishedTime - startTime);
-    } catch (error) {
-      console.error('atob/btoa error:', error);
-      setAtobBtoaResult(-1); // Indicate error
+  const runQuick = async (src: string): Promise<number> => {
+    let d = src;
+    await sleep(1);
+    const t = performance.now();
+    for (let i = 0; i < 30; i++) {
+      const bytes = quickToByteArray(d);
+      d = quickFromByteArray(bytes);
     }
-    setProcessingAtobBtoa(false);
+    return performance.now() - t;
   };
 
-  // atob/btoa benchmark (native browser API) - Large image
-  const handleAtobBtoaLargePress = async () => {
-    setProcessingAtobBtoaLarge(true);
-    let dataToProcess = largeData;
-    await sleep(1);
-    const startTime = performance.now();
+  // ── atob/btoa ─────────────────────────────────────────────────────────────
 
+  const runAtob = async (src: string): Promise<number> => {
+    let d = src;
+    await sleep(1);
+    const t = performance.now();
     try {
-      for (let iter = 0; iter < 30; iter++) {
-        const decoded = atob(dataToProcess);
-        dataToProcess = btoa(decoded);
+      for (let i = 0; i < 30; i++) {
+        const bin = atob(d);
+        d = btoa(bin);
       }
-      const finishedTime = performance.now();
-      console.log(
-        'atob/btoa Large done! took',
-        finishedTime - startTime,
-        'milliseconds'
-      );
-      setAtobBtoaLargeResult(finishedTime - startTime);
-    } catch (error) {
-      console.error('atob/btoa Large error:', error);
-      setAtobBtoaLargeResult(-1); // Indicate error
+    } catch {
+      return -1;
     }
-    setProcessingAtobBtoaLarge(false);
+    return performance.now() - t;
   };
 
-  // Large image base64-js benchmark
-  const handleJSBase64LargePress = async () => {
-    setProcessingJSBase64Large(true);
-    let dataToProcess = largeData;
+  // ── decodeBuffer ──────────────────────────────────────────────────────────
+
+  const runDecodeBuffer = async (src: string): Promise<number> => {
+    const encoded = encode(src);
     await sleep(1);
-    const startTime = performance.now();
+    const t = performance.now();
+    for (let i = 0; i < 30; i++) decodeBuffer(encoded);
+    return performance.now() - t;
+  };
 
-    for (let iter = 0; iter < 30; iter++) {
-      const decoded = jsBase64.toByteArray(dataToProcess);
-      dataToProcess = jsBase64.fromByteArray(decoded);
-    }
-    const finishedTime = performance.now();
-    console.log(
-      'base64-js Large done! took',
-      finishedTime - startTime,
-      'milliseconds'
-    );
-    setJSBase64LargeResult(finishedTime - startTime);
-    setProcessingJSBase64Large(false);
+  // ── encodeBuffer ──────────────────────────────────────────────────────────
+
+  const runEncodeBuffer = async (src: string): Promise<number> => {
+    const binary = decodeBuffer(src);
+    await sleep(1);
+    const t = performance.now();
+    for (let i = 0; i < 30; i++) encodeBuffer(binary);
+    return performance.now() - t;
   };
 
-  // Large Nitro C++ base64 benchmark
-  const handleObjcBase64Press = async () => {
-    setProcessingObjcBase64(true);
-    let dataToProcess = largeData;
+  // ── fromByteArray ─────────────────────────────────────────────────────────
+
+  const runFromByteArray = async (src: string): Promise<number> => {
+    const bytes = new Uint8Array(decodeBuffer(src));
     await sleep(1);
-    const startTime = performance.now();
-    for (let iter = 0; iter < 30; iter++) {
-      const decoded = encode(dataToProcess);
-      dataToProcess = decode(decoded);
-    }
-    const finishedTime = performance.now();
-    console.log(
-      'Nitro C++ Large done! took',
-      finishedTime - startTime,
-      'milliseconds'
-    );
-    setObjcBase64Result(finishedTime - startTime);
-    setProcessingObjcBase64(false);
+    const t = performance.now();
+    for (let i = 0; i < 30; i++) fromByteArray(bytes);
+    return performance.now() - t;
   };
 
-  const calculateSpeedup = (baseTime: number, compareTime: number) => {
-    if (!baseTime || !compareTime || compareTime <= 0) return '';
-    return `(${round(baseTime / compareTime, 2)}x faster)`;
+  // ── toByteArray ───────────────────────────────────────────────────────────
+
+  const runToByteArray = async (src: string): Promise<number> => {
+    const encoded = encode(src);
+    await sleep(1);
+    const t = performance.now();
+    for (let i = 0; i < 30; i++) toByteArray(encoded);
+    return performance.now() - t;
   };
 
-  return (
-    <View>
-      <Text style={styles.sectionTitle}>Small Image (7KB) - 30 iterations</Text>
+  // ── Run all ───────────────────────────────────────────────────────────────
 
-      <View style={styles.lib}>
-        <Text style={styles.heading}>Nitro Simdutf C++</Text>
-        <Text style={styles.result}>
-          {nativeBase64Result > 0 ? `${round(nativeBase64Result, 2)}ms` : ''}
-        </Text>
-      </View>
+  const handleRunAll = async () => {
+    setProcessing(true);
 
-      <View style={styles.lib}>
-        <Text style={styles.heading}>base64-js (JS)</Text>
-        <Text style={styles.result}>
-          {jsBase64Result > 0
-            ? `${round(jsBase64Result, 2)}ms ${calculateSpeedup(jsBase64Result, nativeBase64Result)}`
-            : ''}
-        </Text>
-      </View>
+    const [n, nL, q, qL, a, aL, db, dbL, eb, ebL, fba, fbaL, tba, tbaL] =
+      await Promise.all([
+        runNitro(data),
+        runNitro(largeData),
+        runQuick(data),
+        runQuick(largeData),
+        runAtob(data),
+        runAtob(largeData),
+        runDecodeBuffer(data),
+        runDecodeBuffer(largeData),
+        runEncodeBuffer(data),
+        runEncodeBuffer(largeData),
+        runFromByteArray(data),
+        runFromByteArray(largeData),
+        runToByteArray(data),
+        runToByteArray(largeData),
+      ]);
 
-      <View style={styles.lib}>
-        <Text style={styles.heading}>atob/btoa (Native)</Text>
-        <Text style={styles.result}>
-          {atobBtoaResult > 0
-            ? `${round(atobBtoaResult, 2)}ms ${calculateSpeedup(atobBtoaResult, nativeBase64Result)}`
-            : atobBtoaResult === -1
-              ? 'Error/Not supported'
-              : ''}
-        </Text>
-      </View>
+    setNitroResult(n);
+    setNitroLargeResult(nL);
+    setQuickResult(q);
+    setQuickLargeResult(qL);
+    setAtobResult(a);
+    setAtobLargeResult(aL);
+    setDecodeBufferResult(db);
+    setDecodeBufferLargeResult(dbL);
+    setEncodeBufferResult(eb);
+    setEncodeBufferLargeResult(ebL);
+    setFromByteArrayResult(fba);
+    setFromByteArrayLargeResult(fbaL);
+    setToByteArrayResult(tba);
+    setToByteArrayLargeResult(tbaL);
 
-      <Text style={styles.sectionTitle}>
-        Large Image (1.3MB) - 30 iterations
+    setProcessing(false);
+  };
+
+  // ── Render ────────────────────────────────────────────────────────────────
+
+  const Row = ({
+    label,
+    ms,
+    base,
+  }: {
+    label: string;
+    ms: number;
+    base: number;
+  }) => (
+    <View style={styles.lib}>
+      <Text style={styles.heading}>{label}</Text>
+      <Text style={styles.result}>
+        {ms > 0
+          ? `${round(ms, 2)}ms ${speedup(ms, base)}`
+          : ms === -1
+            ? 'Not supported'
+            : ''}
       </Text>
+    </View>
+  );
 
-      <View style={styles.lib}>
-        <Text style={styles.heading}>Nitro Simdutf C++</Text>
-        <Text style={styles.result}>
-          {objcBase64Result > 0 ? `${round(objcBase64Result, 2)}ms` : ''}
-        </Text>
-      </View>
+  return (
+    <View>
+      <Text style={styles.sectionTitle}>Small Image (7KB) — 30 iterations</Text>
 
       <View style={styles.lib}>
-        <Text style={styles.heading}>base64-js (JS)</Text>
+        <Text style={styles.heading}>Nitro simdutf C++ (string)</Text>
         <Text style={styles.result}>
-          {jsBase64LargeResult > 0
-            ? `${round(jsBase64LargeResult, 2)}ms ${calculateSpeedup(jsBase64LargeResult, objcBase64Result)}`
-            : ''}
+          {nitroResult > 0 ? `${round(nitroResult, 2)}ms` : ''}
         </Text>
       </View>
+      <Row
+        label="quick-base64 (Uint8Array)"
+        ms={quickResult}
+        base={nitroResult}
+      />
+      <Row label="atob/btoa (Hermes)" ms={atobResult} base={nitroResult} />
+      <Row
+        label="decodeBuffer (ArrayBuffer)"
+        ms={decodeBufferResult}
+        base={nitroResult}
+      />
+      <Row
+        label="encodeBuffer (ArrayBuffer)"
+        ms={encodeBufferResult}
+        base={nitroResult}
+      />
+      <Row
+        label="fromByteArray (Uint8Array)"
+        ms={fromByteArrayResult}
+        base={nitroResult}
+      />
+      <Row
+        label="toByteArray (Uint8Array)"
+        ms={toByteArrayResult}
+        base={nitroResult}
+      />
+
+      <Text style={styles.sectionTitle}>
+        Large Image (1.3MB) — 30 iterations
+      </Text>
 
       <View style={styles.lib}>
-        <Text style={styles.heading}>atob/btoa (Native)</Text>
+        <Text style={styles.heading}>Nitro simdutf C++ (string)</Text>
         <Text style={styles.result}>
-          {atobBtoaLargeResult > 0
-            ? `${round(atobBtoaLargeResult, 2)}ms ${calculateSpeedup(atobBtoaLargeResult, objcBase64Result)}`
-            : atobBtoaLargeResult === -1
-              ? 'Error/Not supported'
-              : ''}
+          {nitroLargeResult > 0 ? `${round(nitroLargeResult, 2)}ms` : ''}
         </Text>
       </View>
+      <Row
+        label="quick-base64 (Uint8Array)"
+        ms={quickLargeResult}
+        base={nitroLargeResult}
+      />
+      <Row
+        label="atob/btoa (Hermes)"
+        ms={atobLargeResult}
+        base={nitroLargeResult}
+      />
+      <Row
+        label="decodeBuffer (ArrayBuffer)"
+        ms={decodeBufferLargeResult}
+        base={nitroLargeResult}
+      />
+      <Row
+        label="encodeBuffer (ArrayBuffer)"
+        ms={encodeBufferLargeResult}
+        base={nitroLargeResult}
+      />
+      <Row
+        label="fromByteArray (Uint8Array)"
+        ms={fromByteArrayLargeResult}
+        base={nitroLargeResult}
+      />
+      <Row
+        label="toByteArray (Uint8Array)"
+        ms={toByteArrayLargeResult}
+        base={nitroLargeResult}
+      />
 
-      <Pressable
-        onPress={() => {
-          handleNativeBase64Press();
-          handleJSBase64Press();
-          handleAtobBtoaPress();
-          handleObjcBase64Press();
-          handleJSBase64LargePress();
-          handleAtobBtoaLargePress();
-        }}
-        style={styles.button}
-      >
+      <Pressable onPress={handleRunAll} style={styles.button}>
         <Text style={styles.pressable}>
-          {processingNativeBase64 ||
-          processingJSBase64 ||
-          processingObjcBase64 ||
-          processingAtobBtoa ||
-          processingAtobBtoaLarge ||
-          processingJSBase64Large
-            ? 'Processing...'
-            : 'Run Benchmarks'}
+          {processing ? 'Processing...' : 'Run Benchmarks'}
         </Text>
       </Pressable>
     </View>
@@ -262,11 +296,6 @@ const Benchmarks2 = () => {
 export default Benchmarks2;
 
 const styles = StyleSheet.create({
-  box: {
-    width: 60,
-    height: 60,
-    marginVertical: 20,
-  },
   lib: {
     flexDirection: 'row',
     justifyContent: 'space-between',
@@ -292,11 +321,6 @@ const styles = StyleSheet.create({
     marginTop: 20,
     borderRadius: 8,
   },
-  speedup: {
-    marginVertical: 5,
-    fontSize: 18,
-    textAlign: 'center',
-  },
   sectionTitle: {
     fontSize: 16,
     fontWeight: 'bold',
diff --git a/nitro.json b/nitro.json
index f896413..26f1b00 100644
--- a/nitro.json
+++ b/nitro.json
@@ -9,7 +9,10 @@
   },
   "autolinking": {
     "NitroBase64": {
-      "cpp": "NitroBase64"
+      "all": {
+        "language": "c++",
+        "implementationClassName": "NitroBase64"
+      }
     }
   },
   "ignorePaths": ["node_modules"]
diff --git a/nitrogen/generated/android/NitroBase64+autolinking.cmake b/nitrogen/generated/android/NitroBase64+autolinking.cmake
index 0602aee..2c51da3 100644
--- a/nitrogen/generated/android/NitroBase64+autolinking.cmake
+++ b/nitrogen/generated/android/NitroBase64+autolinking.cmake
@@ -2,7 +2,7 @@
 # NitroBase64+autolinking.cmake
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2025 Marc Rousavy @ Margelo
+# Copyright © Marc Rousavy @ Margelo
 #
 
 # This is a CMake file that adds all files generated by Nitrogen
diff --git a/nitrogen/generated/android/NitroBase64+autolinking.gradle b/nitrogen/generated/android/NitroBase64+autolinking.gradle
index 1cef298..4e22201 100644
--- a/nitrogen/generated/android/NitroBase64+autolinking.gradle
+++ b/nitrogen/generated/android/NitroBase64+autolinking.gradle
@@ -2,7 +2,7 @@
 /// NitroBase64+autolinking.gradle
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 /// This is a Gradle file that adds all files generated by Nitrogen
diff --git a/nitrogen/generated/android/NitroBase64OnLoad.cpp b/nitrogen/generated/android/NitroBase64OnLoad.cpp
index 1a14934..9173907 100644
--- a/nitrogen/generated/android/NitroBase64OnLoad.cpp
+++ b/nitrogen/generated/android/NitroBase64OnLoad.cpp
@@ -2,7 +2,7 @@
 /// NitroBase64OnLoad.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #ifndef BUILDING_NITROBASE64_WITH_GENERATED_CMAKE_PROJECT
@@ -20,25 +20,30 @@
 namespace margelo::nitro::nitrobase64 {
 
 int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::nitrobase64::registerAllNatives();
+  });
+}
+
+
+
+void registerAllNatives() {
   using namespace margelo::nitro;
   using namespace margelo::nitro::nitrobase64;
-  using namespace facebook;
-
-  return facebook::jni::initialize(vm, [] {
-    // Register native JNI methods
-    
-
-    // Register Nitro Hybrid Objects
-    HybridObjectRegistry::registerHybridObjectConstructor(
-      "NitroBase64",
-      []() -> std::shared_ptr<HybridObject> {
-        static_assert(std::is_default_constructible_v<NitroBase64>,
-                      "The HybridObject \"NitroBase64\" is not default-constructible! "
-                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
-        return std::make_shared<NitroBase64>();
-      }
-    );
-  });
+
+  // Register native JNI methods
+  
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroBase64",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<NitroBase64>,
+                    "The HybridObject \"NitroBase64\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<NitroBase64>();
+    }
+  );
 }
 
 } // namespace margelo::nitro::nitrobase64
diff --git a/nitrogen/generated/android/NitroBase64OnLoad.hpp b/nitrogen/generated/android/NitroBase64OnLoad.hpp
index c4ac6d1..9208fde 100644
--- a/nitrogen/generated/android/NitroBase64OnLoad.hpp
+++ b/nitrogen/generated/android/NitroBase64OnLoad.hpp
@@ -2,24 +2,33 @@
 /// NitroBase64OnLoad.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include <jni.h>
+#include <functional>
 #include <NitroModules/NitroDefines.hpp>
 
 namespace margelo::nitro::nitrobase64 {
 
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
   /**
-   * Initializes the native (C++) part of NitroBase64, and autolinks all Hybrid Objects.
-   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`).
+   * Register the native (C++) part of NitroBase64, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
    * Example:
    * ```cpp (cpp-adapter.cpp)
    * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-   *   return margelo::nitro::nitrobase64::initialize(vm);
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroBase64 HybridObjects
+   *     margelo::nitro::nitrobase64::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
    * }
    * ```
    */
-  int initialize(JavaVM* vm);
+  void registerAllNatives();
 
 } // namespace margelo::nitro::nitrobase64
diff --git a/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrobase64/NitroBase64OnLoad.kt b/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrobase64/NitroBase64OnLoad.kt
index dc4eb11..7418548 100644
--- a/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrobase64/NitroBase64OnLoad.kt
+++ b/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrobase64/NitroBase64OnLoad.kt
@@ -2,7 +2,7 @@
 /// NitroBase64OnLoad.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 package com.margelo.nitro.nitrobase64
diff --git a/nitrogen/generated/ios/NitroBase64+autolinking.rb b/nitrogen/generated/ios/NitroBase64+autolinking.rb
index 02f41ce..656ede5 100644
--- a/nitrogen/generated/ios/NitroBase64+autolinking.rb
+++ b/nitrogen/generated/ios/NitroBase64+autolinking.rb
@@ -2,7 +2,7 @@
 # NitroBase64+autolinking.rb
 # This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 # https://github.com/mrousavy/nitro
-# Copyright © 2025 Marc Rousavy @ Margelo
+# Copyright © Marc Rousavy @ Margelo
 #
 
 # This is a Ruby script that adds all files generated by Nitrogen
@@ -52,9 +52,11 @@ def add_nitrogen_files(spec)
   spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
     # Use C++ 20
     "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
-    # Enables C++ <-> Swift interop (by default it's only C)
+    # Enables C++ <-> Swift interop (by default it's only ObjC)
     "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
     # Enables stricter modular headers
     "DEFINES_MODULE" => "YES",
+    # Disable auto-generated ObjC header for Swift (Static linkage on Xcode 26.4 breaks here)
+    "SWIFT_INSTALL_OBJC_HEADER" => "NO",
   })
 end
diff --git a/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.cpp b/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.cpp
index 8d77468..ea1cf66 100644
--- a/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.cpp
+++ b/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.cpp
@@ -2,7 +2,7 @@
 /// NitroBase64-Swift-Cxx-Bridge.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "NitroBase64-Swift-Cxx-Bridge.hpp"
diff --git a/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.hpp b/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.hpp
index 0868b04..c06a4d2 100644
--- a/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.hpp
+++ b/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Bridge.hpp
@@ -2,7 +2,7 @@
 /// NitroBase64-Swift-Cxx-Bridge.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Umbrella.hpp b/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Umbrella.hpp
index b38ad5e..e986634 100644
--- a/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Umbrella.hpp
+++ b/nitrogen/generated/ios/NitroBase64-Swift-Cxx-Umbrella.hpp
@@ -2,7 +2,7 @@
 /// NitroBase64-Swift-Cxx-Umbrella.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
diff --git a/nitrogen/generated/ios/NitroBase64Autolinking.mm b/nitrogen/generated/ios/NitroBase64Autolinking.mm
index b703394..68c6450 100644
--- a/nitrogen/generated/ios/NitroBase64Autolinking.mm
+++ b/nitrogen/generated/ios/NitroBase64Autolinking.mm
@@ -2,7 +2,7 @@
 /// NitroBase64Autolinking.mm
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #import <Foundation/Foundation.h>
diff --git a/nitrogen/generated/ios/NitroBase64Autolinking.swift b/nitrogen/generated/ios/NitroBase64Autolinking.swift
index 3dfbabd..5f773f4 100644
--- a/nitrogen/generated/ios/NitroBase64Autolinking.swift
+++ b/nitrogen/generated/ios/NitroBase64Autolinking.swift
@@ -2,9 +2,13 @@
 /// NitroBase64Autolinking.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
 public final class NitroBase64Autolinking {
   public typealias bridge = margelo.nitro.nitrobase64.bridge.swift
 
diff --git a/nitrogen/generated/shared/c++/HybridNitroBase64Spec.cpp b/nitrogen/generated/shared/c++/HybridNitroBase64Spec.cpp
index f8c1765..6dbcbb9 100644
--- a/nitrogen/generated/shared/c++/HybridNitroBase64Spec.cpp
+++ b/nitrogen/generated/shared/c++/HybridNitroBase64Spec.cpp
@@ -2,7 +2,7 @@
 /// HybridNitroBase64Spec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "HybridNitroBase64Spec.hpp"
@@ -17,6 +17,8 @@ namespace margelo::nitro::nitrobase64 {
       prototype.registerHybridMethod("install", &HybridNitroBase64Spec::install);
       prototype.registerHybridMethod("encode", &HybridNitroBase64Spec::encode);
       prototype.registerHybridMethod("decode", &HybridNitroBase64Spec::decode);
+      prototype.registerHybridMethod("decodeBuffer", &HybridNitroBase64Spec::decodeBuffer);
+      prototype.registerHybridMethod("encodeBuffer", &HybridNitroBase64Spec::encodeBuffer);
     });
   }
 
diff --git a/nitrogen/generated/shared/c++/HybridNitroBase64Spec.hpp b/nitrogen/generated/shared/c++/HybridNitroBase64Spec.hpp
index a707954..a00b5ab 100644
--- a/nitrogen/generated/shared/c++/HybridNitroBase64Spec.hpp
+++ b/nitrogen/generated/shared/c++/HybridNitroBase64Spec.hpp
@@ -2,7 +2,7 @@
 /// HybridNitroBase64Spec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -16,6 +16,7 @@
 
 
 #include <string>
+#include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::nitrobase64 {
 
@@ -50,7 +51,9 @@ namespace margelo::nitro::nitrobase64 {
       // Methods
       virtual void install() = 0;
       virtual std::string encode(const std::string& input, bool urlSafe) = 0;
-      virtual std::string decode(const std::string& base64, bool urlSafe) = 0;
+      virtual std::string decode(const std::string& base64) = 0;
+      virtual std::shared_ptr<ArrayBuffer> decodeBuffer(const std::string& base64) = 0;
+      virtual std::string encodeBuffer(const std::shared_ptr<ArrayBuffer>& input, bool urlSafe) = 0;
 
     protected:
       // Hybrid Setup
diff --git a/package.json b/package.json
index 4a568aa..55623a4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-base64",
-  "version": "0.8.2",
+  "version": "1.1.0",
   "description": "NitroModule Base64",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -79,12 +79,12 @@
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
     "jest": "^29.7.0",
-    "nitrogen": "^0.29.8",
+    "nitrogen": "^0.35.6",
     "prettier": "^3.6.2",
     "react": "19.1.0",
     "react-native": "0.81.1",
     "react-native-builder-bob": "^0.40.13",
-    "react-native-nitro-modules": "^0.29.8",
+    "react-native-nitro-modules": "^0.35.6",
     "release-it": "^19.0.4",
     "turbo": "^2.5.6",
     "typescript": "^5.9.2"
diff --git a/src/NitroBase64.nitro.ts b/src/NitroBase64.nitro.ts
index 48f47d4..a509caf 100644
--- a/src/NitroBase64.nitro.ts
+++ b/src/NitroBase64.nitro.ts
@@ -4,7 +4,9 @@ export interface NitroBase64
   extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   install(): void;
   encode(input: string, urlSafe: boolean): string;
-  decode(base64: string, urlSafe: boolean): string;
+  decode(base64: string): string;
+  decodeBuffer(base64: string): ArrayBuffer;
+  encodeBuffer(input: ArrayBuffer, urlSafe: boolean): string;
 }
 
 // export interface NitroBase64Module extends HybridObject<{ android: 'kotlin' }> {
diff --git a/src/index.tsx b/src/index.tsx
index f827427..ec45442 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -6,14 +6,33 @@ const NitroBase64HybridObject =
 
 // const NitroBase64ModuleHybridObject =
 //   NitroModules.createHybridObject<NitroBase64Module>('NitroBase64Module');
-export function decode(base64: string, urlSafe = false): string {
-  return NitroBase64HybridObject.decode(base64, urlSafe);
+export function decode(base64: string): string {
+  return NitroBase64HybridObject.decode(base64);
 }
 
 export function encode(input: string, urlSafe = false): string {
   return NitroBase64HybridObject.encode(input, urlSafe);
 }
 
+export function decodeBuffer(base64: string): ArrayBuffer {
+  return NitroBase64HybridObject.decodeBuffer(base64);
+}
+
+export function encodeBuffer(input: ArrayBuffer, urlSafe = false): string {
+  return NitroBase64HybridObject.encodeBuffer(input, urlSafe);
+}
+
+export function fromByteArray(input: Uint8Array, urlSafe = false): string {
+  return NitroBase64HybridObject.encodeBuffer(
+    input.buffer as ArrayBuffer,
+    urlSafe
+  );
+}
+
+export function toByteArray(base64: string): Uint8Array {
+  return new Uint8Array(NitroBase64HybridObject.decodeBuffer(base64));
+}
+
 export function install(): void {
   NitroBase64HybridObject.install();
 }
diff --git a/yarn.lock b/yarn.lock
index 18046c3..ec1e0c5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3793,7 +3793,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-styles@npm:^6.1.0":
+"ansi-styles@npm:^6.1.0, ansi-styles@npm:^6.2.1":
   version: 6.2.3
   resolution: "ansi-styles@npm:6.2.3"
   checksum: f1b0829cf048cce870a305819f65ce2adcebc097b6d6479e12e955fd6225df9b9eb8b497083b764df796d94383ff20016cc4dbbae5b40f36138fb65a9d33c2e2
@@ -4584,6 +4584,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cliui@npm:^9.0.1":
+  version: 9.0.1
+  resolution: "cliui@npm:9.0.1"
+  dependencies:
+    string-width: ^7.2.0
+    strip-ansi: ^7.1.0
+    wrap-ansi: ^9.0.0
+  checksum: 143879ae462bf76822f341bf40979f0225fdba8dde6dfe429018b13396fd0532752cc2a809ac48cecc0ea189406184ad7568c0af44eea73d2ac3b432c4c6431f
+  languageName: node
+  linkType: hard
+
 "clone@npm:^1.0.2":
   version: 1.0.4
   resolution: "clone@npm:1.0.4"
@@ -5390,6 +5401,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"emoji-regex@npm:^10.3.0":
+  version: 10.6.0
+  resolution: "emoji-regex@npm:10.6.0"
+  checksum: 8785f6a7ec4559c931bd6640f748fe23791f5af4c743b131d458c5551b4aa7da2a9cd882518723cb3859e8b0b59b0cc08f2ce0f8e65c61a026eed71c2dc407d5
+  languageName: node
+  linkType: hard
+
 "emoji-regex@npm:^8.0.0":
   version: 8.0.0
   resolution: "emoji-regex@npm:8.0.0"
@@ -6401,6 +6419,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"get-east-asian-width@npm:^1.0.0":
+  version: 1.6.0
+  resolution: "get-east-asian-width@npm:1.6.0"
+  checksum: 88faf98aaade2b24ad260be369b026d979ff4d0e6201bfd991654da17f2aa720bbddb812ce5612110eef6b469d8370c863f69a2f9818d61733f1eb2a83d779b8
+  languageName: node
+  linkType: hard
+
 "get-east-asian-width@npm:^1.3.0":
   version: 1.4.0
   resolution: "get-east-asian-width@npm:1.4.0"
@@ -9140,18 +9165,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nitrogen@npm:^0.29.8":
-  version: 0.29.8
-  resolution: "nitrogen@npm:0.29.8"
+"nitrogen@npm:^0.35.6":
+  version: 0.35.6
+  resolution: "nitrogen@npm:0.35.6"
   dependencies:
     chalk: ^5.3.0
-    react-native-nitro-modules: ^0.29.8
+    react-native-nitro-modules: ^0.35.6
     ts-morph: ^27.0.0
-    yargs: ^17.7.2
+    yargs: ^18.0.0
     zod: ^4.0.5
   bin:
     nitrogen: lib/index.js
-  checksum: ec56919ee570e1a9475ec95a90ed3779110bf9139811102d63d3b40a9b2747ab54962c081ff4f0cc5f0df83f06719f020d55489ce8d4f2a7a08ea1d0299a1977
+  checksum: 105ff9cf455c3c12def88181e37d2b681b5b50dc891a725db9e36e16695809f9c80056b60bc94d19dfaf7bf71c77820660f7ac9f29f9e5b7ed3e5c2e0a5e8d8a
   languageName: node
   linkType: hard
 
@@ -10120,8 +10145,8 @@ __metadata:
     react-native: 0.81.1
     react-native-builder-bob: ^0.40.13
     react-native-monorepo-config: ^0.1.9
-    react-native-nitro-modules: ^0.29.8
-    react-native-quick-base64: ^2.2.2
+    react-native-nitro-modules: ^0.35.6
+    react-native-quick-base64: ^3.0.0
     react-native-safe-area-context: ^5.5.2
   languageName: unknown
   linkType: soft
@@ -10146,12 +10171,12 @@ __metadata:
     eslint-config-prettier: ^10.1.8
     eslint-plugin-prettier: ^5.5.4
     jest: ^29.7.0
-    nitrogen: ^0.29.8
+    nitrogen: ^0.35.6
     prettier: ^3.6.2
     react: 19.1.0
     react-native: 0.81.1
     react-native-builder-bob: ^0.40.13
-    react-native-nitro-modules: ^0.29.8
+    react-native-nitro-modules: ^0.35.6
     release-it: ^19.0.4
     turbo: ^2.5.6
     typescript: ^5.9.2
@@ -10162,23 +10187,23 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"react-native-nitro-modules@npm:^0.29.8":
-  version: 0.29.8
-  resolution: "react-native-nitro-modules@npm:0.29.8"
+"react-native-nitro-modules@npm:^0.35.6":
+  version: 0.35.6
+  resolution: "react-native-nitro-modules@npm:0.35.6"
   peerDependencies:
     react: "*"
     react-native: "*"
-  checksum: 54e9ddb7d9c28f39000e9ec06c1ae59fde9dc53454bade6697ae842c4996becd388cdfa1bb0cb504a6ddc25873e1409533a141f94d2f36153bdbf4bf51cf97b1
+  checksum: b057dc606c4717bff2447cff3efdeebf5cd7342fa11b3f51cfd420ccce1224d0b4be5999ea63c9856721520f1cbb50fba9372109f49a4c8b14202d7ab4d3b37e
   languageName: node
   linkType: hard
 
-"react-native-quick-base64@npm:^2.2.2":
-  version: 2.2.2
-  resolution: "react-native-quick-base64@npm:2.2.2"
+"react-native-quick-base64@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "react-native-quick-base64@npm:3.0.0"
   peerDependencies:
     react: "*"
     react-native: "*"
-  checksum: 51cd8df0b7f78d4c10996f157927cc075b8a9e85f7d0e48790a4247a033ca335e440c96572969fb6f6b49135d51dbf87c6d659fba509b51b9237957d41a6c580
+  checksum: b9d447a66178e8f72ae3a6d852056bb928256bb9c8703c0b3bcfb9338df12d89ff82617535114f3d04643c908aaf0b48d5c46b0f0fb281bab34855d95c23f448
   languageName: node
   linkType: hard
 
@@ -11098,6 +11123,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"string-width@npm:^7.0.0, string-width@npm:^7.2.0":
+  version: 7.2.0
+  resolution: "string-width@npm:7.2.0"
+  dependencies:
+    emoji-regex: ^10.3.0
+    get-east-asian-width: ^1.0.0
+    strip-ansi: ^7.1.0
+  checksum: 42f9e82f61314904a81393f6ef75b832c39f39761797250de68c041d8ba4df2ef80db49ab6cd3a292923a6f0f409b8c9980d120f7d32c820b4a8a84a2598a295
+  languageName: node
+  linkType: hard
+
 "string-width@npm:^8.1.0":
   version: 8.1.0
   resolution: "string-width@npm:8.1.0"
@@ -12020,6 +12056,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"wrap-ansi@npm:^9.0.0":
+  version: 9.0.2
+  resolution: "wrap-ansi@npm:9.0.2"
+  dependencies:
+    ansi-styles: ^6.2.1
+    string-width: ^7.0.0
+    strip-ansi: ^7.1.0
+  checksum: 9827bf8bbb341d2d15f26d8507d98ca2695279359073422fe089d374b30e233d24ab95beca55cf9ab8dcb89face00e919be4158af50d4b6d8eab5ef4ee399e0c
+  languageName: node
+  linkType: hard
+
 "wrappy@npm:1":
   version: 1.0.2
   resolution: "wrappy@npm:1.0.2"
@@ -12131,6 +12178,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"yargs-parser@npm:^22.0.0":
+  version: 22.0.0
+  resolution: "yargs-parser@npm:22.0.0"
+  checksum: 55df0d94f3f9f933f1349f244ddf72a6978a9d5a972b69332965cdfd5ec849ff26386965512f4179065b0573cc6e8df33ca44334958a892c47fedae08a967c99
+  languageName: node
+  linkType: hard
+
 "yargs@npm:^15.1.0":
   version: 15.4.1
   resolution: "yargs@npm:15.4.1"
@@ -12150,7 +12204,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:^17.0.0, yargs@npm:^17.3.1, yargs@npm:^17.5.1, yargs@npm:^17.6.2, yargs@npm:^17.7.2":
+"yargs@npm:^17.0.0, yargs@npm:^17.3.1, yargs@npm:^17.5.1, yargs@npm:^17.6.2":
   version: 17.7.2
   resolution: "yargs@npm:17.7.2"
   dependencies:
@@ -12165,6 +12219,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"yargs@npm:^18.0.0":
+  version: 18.0.0
+  resolution: "yargs@npm:18.0.0"
+  dependencies:
+    cliui: ^9.0.1
+    escalade: ^3.1.1
+    get-caller-file: ^2.0.5
+    string-width: ^7.2.0
+    y18n: ^5.0.5
+    yargs-parser: ^22.0.0
+  checksum: a7cf1b97cb4e81c059f78fd32a4160505d421ecdce5409f5e3840fdcc4c982885fc645b44af961eab94d673cb46f81207d831aa87862246907ffacf45884976a
+  languageName: node
+  linkType: hard
+
 "yocto-queue@npm:^0.1.0":
   version: 0.1.0
   resolution: "yocto-queue@npm:0.1.0"

From 24228bcf044b325319e43533c479aa1aa6b65e24 Mon Sep 17 00:00:00 2001
From: Rom <chanphiromsok2109@gmail.com>
Date: Sun, 17 May 2026 14:53:25 +0700
Subject: [PATCH 2/3] feat: update README and project files for NitroBase64
 v1.1.1 release

---
 README.md                                     | 164 +++++++++++-------
 docs/android.png                              | Bin 86456 -> 314001 bytes
 docs/ios.png                                  | Bin 121466 -> 286991 bytes
 example/index.js                              |   2 +-
 .../project.pbxproj                           |  58 +++----
 example/ios/Podfile.lock                      |   4 +-
 package.json                                  |   2 +-
 7 files changed, 136 insertions(+), 94 deletions(-)

diff --git a/README.md b/README.md
index 660bcef..b847371 100644
--- a/README.md
+++ b/README.md
@@ -1,107 +1,149 @@
-# NitroBase64
+# react-native-nitro-base64 ⚡
 
-A high-performance, cross-platform Base64 encoding/decoding module for React Native, powered by C++ and simdutf. Implements WHATWG forgiving-base64 and supports both standard and URL-safe variants.
+The fastest Base64 library for React Native — powered by [simdutf](https://github.com/simdutf/simdutf) SIMD C++ and [Nitro Modules](https://github.com/mrousavy/nitro).
 
-| iPhone                                            | Android                                             |
-| ------------------------------------------------- | --------------------------------------------------- |
+Processes a 1.3MB image **26x faster** than `atob`/`btoa` and **1.8x faster** than `react-native-quick-base64`.
+
+| iPhone | Android |
+| --- | --- |
 | ![iPhone](./docs/ios.png) | ![Android](./docs/android.png) |
-## Features
-- Fast C++ implementation using [simdutf](https://github.com/simdutf/simdutf)
-- WHATWG forgiving-base64 compliance (removes whitespace, optional padding)
-- Supports both standard and URL-safe base64
-- Consistent API for iOS and Android
-- Detailed error handling
 
-## Installation
+---
+
+## 🤔 Why this library?
+
+Most React Native base64 libraries hit the same bottlenecks:
+
+- 🐢 **Pure JS** (`base64-js`) — slow. No native acceleration.
+- ⚠️ **`atob`/`btoa`** — fast for tiny strings, falls apart on binary data at scale.
+- ⚠️ **String-based native** — crosses the JSI bridge as UTF-16, doubling memory for binary payloads.
+
+`react-native-nitro-base64` uses SIMD instructions (AVX-512 on x86, NEON on Apple Silicon) to process 64 bytes per CPU instruction, and exposes `ArrayBuffer`/`Uint8Array` APIs that bypass string marshaling entirely.
+
+### 📊 Benchmark — 30 iterations, iPhone (Apple Silicon)
+
+> Tested against `react-native-quick-base64@3.0.0`
+
+
+#### Small image (7KB)
+
+| Library | Time | vs. nitro-base64 |
+|---|---|---|
+| ⚡ **nitro-base64** `decodeBuffer` / `fromByteArray` | **0.06ms** | — |
+| react-native-quick-base64 | 0.11ms | 1.8x slower |
+| atob / btoa (Hermes) | 1.04ms | 17x slower |
+
+#### Large image (1.3MB)
+
+| Library | Time | vs. nitro-base64 |
+|---|---|---|
+| ⚡ **nitro-base64** `decodeBuffer` / `fromByteArray` | **7.5ms** | — |
+| react-native-quick-base64 | 13.6ms | 1.8x slower |
+| atob / btoa (Hermes) | 203ms | 26x slower |
+
+---
+
+## 📦 Installation
 
 ```sh
 yarn add react-native-nitro-base64
 yarn add react-native-nitro-modules
 ```
 
-### Linking
-This module uses [react-native-nitro-modules](https://github.com/mrousavy/nitro). Follow Nitro's setup instructions for autolinking and native builds.
+Then follow [Nitro's setup guide](https://nitro.margelo.com) for autolinking.
 
-## API
+### 🔧 Setup
 
-| Function | Input | Output | Use case |
-|---|---|---|---|
-| `encode(str, urlSafe?)` | binary string | base64 string | Text/JWT encoding |
-| `decode(base64)` | base64 string | binary string | Text/JWT decoding — accepts standard and URL-safe automatically |
-| `encodeBuffer(ArrayBuffer, urlSafe?)` | ArrayBuffer | base64 string | Image/file → base64 |
-| `decodeBuffer(base64)` | base64 string | ArrayBuffer | base64 → raw binary — accepts standard and URL-safe automatically |
-| `fromByteArray(Uint8Array, urlSafe?)` | Uint8Array | base64 string | Crypto/hashing output → base64 |
-| `toByteArray(base64)` | base64 string | Uint8Array | base64 → typed binary — accepts standard and URL-safe automatically |
+Call `install()` once before your app mounts:
 
-### Which one should I use?
+```js
+// index.js
+import { install } from 'react-native-nitro-base64';
+import { AppRegistry } from 'react-native';
+import App from './src/App';
+import { name as appName } from './app.json';
+
+install();
+AppRegistry.registerComponent(appName, () => App);
+```
+
+---
+
+## 📖 API
+
+| Function | Input → Output | Notes |
+|---|---|---|
+| `encode(str, urlSafe?)` | string → base64 string | URL-safe optional |
+| `decode(base64)` | base64 string → string | Auto-detects standard & URL-safe |
+| `encodeBuffer(ArrayBuffer, urlSafe?)` | ArrayBuffer → base64 string | 🚀 Zero-copy, fastest for images |
+| `decodeBuffer(base64)` | base64 string → ArrayBuffer | 🚀 Zero-copy, fastest for images |
+| `fromByteArray(Uint8Array, urlSafe?)` | Uint8Array → base64 string | Drop-in for `react-native-quick-base64` |
+| `toByteArray(base64)` | base64 string → Uint8Array | Drop-in for `react-native-quick-base64` |
+
+---
+
+## 🚀 Usage
 
-**Working with images?** Use `encodeBuffer` / `decodeBuffer`.
+### 🖼️ Images & files — `encodeBuffer` / `decodeBuffer`
 
-Images are binary data. Passing them through a JS string crosses the JSI bridge as UTF-16, doubling memory and adding overhead. `ArrayBuffer` avoids that — raw bytes go directly to C++.
+Images are binary data. Sending binary through a JS string crosses the JSI bridge as UTF-16, doubling memory. `ArrayBuffer` skips that entirely — raw bytes go straight to C++.
 
-```typescript
+```ts
 import { encodeBuffer, decodeBuffer } from 'react-native-nitro-base64';
-import { readFile } from 'react-native-fs';
 
-// Image file → base64 (for API upload)
-const bytes = await readFile(imagePath, 'ascii'); // or use arrayBuffer APIs
-const base64 = encodeBuffer(buffer); // ArrayBuffer → base64
+// Upload image to API
+const response = await fetch(imageUri);
+const buffer = await response.arrayBuffer();
+const base64 = encodeBuffer(buffer); // → "iVBORw0KGgo..."
 
-// base64 from API → display in <Image>
-const buffer = decodeBuffer(base64String); // base64 → ArrayBuffer
+// Decode API response for <Image> component
+const buffer = decodeBuffer(base64String); // → ArrayBuffer
 ```
 
-**Working with text / JWT?** Use `encode` / `decode`.
+### 🔑 Text & JWT — `encode` / `decode`
 
-```typescript
+```ts
 import { encode, decode } from 'react-native-nitro-base64';
 
-const encoded = encode('Hello World!'); // "SGVsbG8gV29ybGQh"
-const decoded = decode(encoded);       // "Hello World!"
+const encoded = encode('Hello World!');  // "SGVsbG8gV29ybGQh"
+const decoded = decode(encoded);         // "Hello World!"
 
-// URL-safe (JWT, URL params)
+// URL-safe for JWT / URL params
 const token = encode(payload, true);
 ```
 
-**Working with Web Crypto / hashing?** Use `fromByteArray` / `toByteArray`.
+### 🔐 Web Crypto & hashing — `fromByteArray` / `toByteArray`
 
-Web Crypto APIs (`crypto.subtle`) return `Uint8Array`. These are drop-in compatible with `react-native-quick-base64`.
+Drop-in replacement for `react-native-quick-base64`. Same API, faster engine.
 
-```typescript
+```ts
 import { fromByteArray, toByteArray } from 'react-native-nitro-base64';
 
-// Hash → base64
+// SHA-256 hash → base64
 const hash = new Uint8Array(await crypto.subtle.digest('SHA-256', data));
 const encoded = fromByteArray(hash);
 
-// base64 → bytes for TextDecoder
+// base64 → text
 const bytes = toByteArray(base64String);
 const text = new TextDecoder().decode(bytes);
 ```
 
-## Setup
+---
 
-```javascript
-// index.js
-import { install } from 'react-native-nitro-base64';
-import { AppRegistry } from 'react-native';
-import { name as appName } from './app.json';
-import App from './src/App';
+## 📱 Platform Support
 
-install(); // call before app mounts
-AppRegistry.registerComponent(appName, () => App);
-```
+| Platform | Engine |
+|---|---|
+| iOS | C++ (simdutf, NEON SIMD) |
+| Android | C++ (simdutf, NEON / AVX2 SIMD) |
 
-## Platform Support
-- **iOS:** C++ implementation via simdutf
-- **Android:** C++ implementation via simdutf
+---
 
-## Error Handling
-Throws descriptive errors for invalid base64 input, remainder issues, or extra bits in padding.
+## 📄 License
 
-## License
 MIT
 
-## Credits
-- [simdutf](https://github.com/simdutf/simdutf)
-- [Nitro Modules](https://github.com/mrousavy/nitro)
+## 🙏 Credits
+
+- [simdutf](https://github.com/simdutf/simdutf) — SIMD-accelerated Unicode & Base64
+- [Nitro Modules](https://github.com/mrousavy/nitro) — JSI native module framework
diff --git a/docs/android.png b/docs/android.png
index 120011b8c06b86ab19ca57331c712e9f7bdc9347..2cb121bbeda4aaaba8bcf62a8c5048f1d57b1dc8 100644
GIT binary patch
literal 314001
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
I*6jZO0h>NXp#T5?

literal 86456
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
boe5U%U#ll{d^-IX@N>cR%Gu&Gw<7)z5KtRO

diff --git a/docs/ios.png b/docs/ios.png
index 0bc2da2e8c604578853f5465fd812d74adfeccd2..501e167bd57a8935d5f6e73af19b61d3a2dd3188 100644
GIT binary patch
literal 286991
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%0A+P8Q<`f1a>C*b7RX_)lhx53V=h9z(
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%0A`)l)jQD*&r}<i_r1fKu
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
Q2k@h>Yka2guPb-|2Nem(x&QzG

literal 121466
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%0D+_Zw^
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%0Db=W%NuFd~BlqWmc}6B*)~O{7i4Arb{66`}`_kdY
zK$!AFb!Suyk8BVbsk^I2R~%j#3YQuL*e(Q3eo|Fdj)cN;d5ku%Eo7A3mR^$Oi+}zQ
zR-Bpc9weRd8z2CVt;Z)V40y}+j>j4MH<pStwI<JV3rZTA7T*GTBD+H(3e0F=?|Dy$
zw4U4zPSNGo4R|%e|Gv}yGe#!XI#pN^un%#zQVy_RvA!5OW0Z8keiCMH%J2$3DGsnL
zWjcs2%$p;DoT6UHdQupi_NF2mKX%6{aZAh^QUay|=Hyn7G{e96uKI|qeI3R@L+tL)
z*({j_ih&DCdY0{ateO+R;Q+Ord$y<P*SIk$3i!sjeRr9)F;s)%b~5h`ONIr&`}3*l
zC?8_#UWuvHewk6^K3e&R1;fOCwM=;-nmH;6h|8bBkYFf-N*BW5jhV_)m#H5gR@N&x
zNnbSOeFj)iAqG`m&{x(`RSjFrlFZGnMH$^fgmO0|z5J>1qiW3jvSPz%*a*v?nNkiE
z#hl@8kJSQHM?_DE`Cgm-9o1SUMV@|41$)MqPyxrpJI6^^R?+2~)y{f2nb-!x$X^_e
zD9$}fJNkS3sS7Jr{4N3%dZV8*50amjMh&2--9E0JYwAv%qs&zm$FM>%R_^3kWrmR=
zyV?@_@Oo5;oDZ56B0nFInWUDBo*>&{4N+u7&_NpBFk_8(gWx~wI^&{cJAO<BZ1YP$
zP4hR?cqqKV(=qYE%Js+ck^J}V#)}p9I9+Vs2sR1+Y)3E!PKg@4dWy2CzlC&K$uc!H
z^@$O)b+qd1>xuk4$3HE&2nW=tGA@$xGT|)*3~jgMTHE&YQ*4xR8JYwk7Ayn$avsUS
z?}F@<b)7z0Gj^OCR0FEb6oHdzp4|h-f&&;5ubJ*(I{Trc<38R!4Oshlx-Tp^>|U-E
zko)mjYJuxZKbt_`!a}hv;)6@A8?V<24N1$;p2?*fk?f>sC{G7~5%T}sSM*;Rm^CyP
zq(w_}bW_pS8DElX5M$ly<9<d-)O?rn$IZNW7SQPo#ALv{AN0B|l8oliiU2lX;aKAk
zh|-Cx#<FKLK-$~Q>(WDvAiB)yuKLTjPVxx31_SJ1JJ!2tZS3>MNXgt+3>~lo_O;b@
z%PzmbqenPGAC4i}Lrjgkr37{C&({yw`Ri7<^|PjmeJ`CkQ3SzdRJg7$H96((5}}zy
z`Gv?IE(*&v&s;yfeLt0`YpgbG*!OL7;+2NQxC~d|friUTlAWlo(ZSEG!NdW)3=G^B
z)~E!(%fexO1209*=VUhT0xN>8nZY#yUoYU`aHw?zkKIVk_HEYU8)JeMjp%Z%-n(!!
zn2NTFGdM%Eu<O^8Sp0_)+U-kn0u^TmZD5ytfvz6cFgcP7=W&~#?AZ$DK|;ybpy8$*
z#W5**lXALnX2;A`gZtVg-1ex=5M!UIYJLvABBB$Oh*}3~QNWA1t}<0zT?vGO9UQ<K
z(!1W*dGeZLT!DGry$OdR(xil2aUxA|Z)-)NC7wntoo-@wf(PSA?;1a@3?^6bhPB%R
z8p4+HlliyAKQpmv#w|ca22}|O9J&X~nA3LJ=*UQ}8H{;c<cT>J6@srVo`g}gth~u6
z-*`N6)Fx+z&2tX_jI`$1X%ov0eh0&B_hd~{_EZyIF(+8NjIL2Xipa~sJP-k_k6)bo
zr~!?^$<pUhe(gVDZDqDQ`*1uqi8f-2VB23L%jhMfy@KW5%#8-V3I?J3d$l6q6n&C8
z-`BWzX>KQd;h7;rd9#wcM@F->-5FaE5@z&%#Y_~a<a9jv*rT=nFtWKUoPfecqvY5B
zoM+Dmg&4oszp=vaE8?#_9v<!_fbIB;XwPbA%_aGEYx&_UsMFVs+T)c%1d|3}g+;+^
z2Qh_$UxFVlJ0YB36i@%WbzoHi_7^X_pWy`ud2RF&Q-`l4Drml&-$;pCkybmoOleWe
zV81XO=f1SUCl<V`94f(tTH^Qm$plGQa26n3)dXt&FC@ks3>LmW?s0KneMo~dYWW$^
zwj~)K>Mb#Sp&I*U%uJpICeYe=*YjrLIW<<J8T%|`QA<Jsrq#fMZ5Nz`R_~B%)>>b7
z0r=xHLq7}&_K~tQI|cHDn^7=GP;q7Cup3a1;lcX2;|aJ{><{y<i-L#pfS+cL3t~E8
zze&eHUQ#zC&kcuj?RWXzLkW`Fxb?%0JFfC_axbC5ZTs#JQw^7l(4Hgt{J@}P2@FfQ
zN3Yk?6^xiJUSmiyq|qerh<)DCs3U~J+I3-JQD-z!IhxgJju7)p>#hfGGa)C9l{P2I
z($ZZ%gYmCf=9nySq4@yE^2?K@H`BQ*OL*!9uBw}RK1lk?(A(E<SoD3u>3~E938%6U
z3DqLK?E&9|UO(=K8a8kg1>d3(Oi@?LPdt|$VIGxa7RNB4%~f17e}N!Y#>WXbi?-Q;
zN@$`BLD4mT=5z!n+0viU(f7Z=K=U?hHVoqqjo6s)MHwXswI%g2mWoE$xj2#aP|)a;
zfl?Sr80E)ZIKSTo%NpN}FgU;bHTU8vD%NTgUU$xdKcrg_obj4n!UZfs(=5KFaqN+}
z;%5^<bLzXgW4sPmYC^DnphNW&rANuzOhIf2>QhO4<)&8-Wo%CkFb*!4^qdVU*8vq9
zddNRba*VT(w$&b;<exw|$m-2@N11(K0OmDN1DqLx34~2=g_~s%9=%We^(ADG+1|j4
ztUpHH9$Oy+@&;2l4ngeR!I)7qg-2mN4bF2&eC0-j;hh_Vbl76{iD8QbRBnnmxaWf|
z`iXD_+Jza}=^gmp?!7Pwb|>|*Yhjq+3>^aWG44ghyFD_P@1nnzwat#kvwEq*ReN5a
zvLqk`tl$lWDQC#6KjLT$PtM&biy#wk%0+S0LUaI_kYK_JiYwJM`VrW<Eqx$}1act9
z>gO>r{?NTGLMQ{b<U80dU?`Oxlo(@EWrRcWp<QhsrLa1->Xv26>pi!UOc-r?*FHNj
zoNBDn;|o97rJug^oc}5j3LtDU5Z90}Hu^Q1cEc0YSX^ilZFv+|22-&As{A00Vb7vL
z8O+BkxTi9o_LMEb%(pyB`0l9lM+|$?uK2rK8o?KpJY6Z0f!BJwpNI~XiOSa`ea*q7
z30tQ_&55A8M}WQ;fn81VW4>q?*q%+&*<5cXG7aLHx@VdBt-?$Va3qi>=|N--l<tWm
zizX2p7JP8`nYm9?Fh)bg<dm4L1FkJGV(<`U%HMs!>uF_YDF2IsOvW;2RLMj+_(Bj1
z%$wvMdz~sfNEAS@r(xgg*D81e2uD}b)1IP+;PXz$=emmNf$>CNVNdvjmj(|O1wMz-
zl;=seg|9B$=`g5APDYQ6@C~off9jnzkoO63O_AMU*?LMr>YjeA+eCdz(L=G0c>3$Z
zyeX_ZjxuE{gr&qrwvqGCN38dAT@Xds5Bq)`_g2lZcouy^l>3o9#i?OyT2e`P&>5oM
zSu7i!SxZgq_PJS(Ndiy2uOS}rU?gmJljJ{rP5K^`JV>Ibj8}iFBR8mP3H#+A=ik?R
z=Ulf(oY_YbOR29EkB9#=idi)wpnWbYk)P3r8Z;zeVNkPxv6W)fg+!7ZWMClr_Li|~
zs%cBha*nu}9xPp5-ba$NdppOG|1A)cb&<{Hy(<1^r&#>Y&p<XqW4W;x*C$a$bYup!
zsc|1kIA9e@>?>r4l*#lU6%EvOH{(hpWG4JmlEiQQE$X4cvbQC7k8Ka4GJbR5QyPkR
z03)S_^RB#+=L##QpKLnF-ZOjsr1({6Di1c)7VcI51RPOAQ`$|H4IRFN{dHapcsA5Z
z>a*5!8$b-&3LZ#c3+<a0#1@m8#@VVZ0&`f9{k)T7Aoj226`I!;W?RA8(g5Ka@GP2R
z&Om8KpP(Qr%eO9fJua{j&nnY9=6%Z%hd#F;_wpcpZB@xFzL}*CiP|4WlZkK-xBG1$
zx?TC7wE66HGc!+%AO<}(4L40S6sNxpiY4!LMr(6RnpG|vHui4;=|)P4lQ@uZvZ`|!
zCQ5GWCREy(Pw`!tx16Q#eAgkBB0_9`71p6fERDu}xKdd2?O{nGE2x3Vw}pvR=#Iw7
zkQOAJW~Cpn(fFsd|MzikmH?f{tNAGEpFfpZLoJL50t6gJ82QF0@i6u26EpKjLYp{y
zi1`lyHC+-VzdKmE+@ag4C9t)W(e>0|jkp~~+oQTN(lXm3>)H8dO~ZNKege9*)$wrP
z(j`Kktcd&9MqXf(5U66MYnlHjE=}Z$FLsKla!vY6XywZQTjdZ2#BA9N!X!R4fT)O*
z0+uXY@Q$H^Vi;|PO$UZ7#n77UQHlzeL?nh!tt=m;rARmeeOaBLYHGIOq@P9m9PFMs
zGB^b1YZMlOQ-qZJt3KZXJTEEeY^&<0ObF*9rn%Mj9PvsxdU0hQ?`{ijkR(zje+bIm
zbv4N?^YnC)!!_DiLg9FTGz+@EpX8!_a#Z<w4Yc?2d3j{zpJjNZbnbVKvv?s$(No28
zy+;By@4_H@Cjb01a5VS+VZqcwC0=B^QAMQ$xF@SUOBKv&YN!pSmi`XTRvur&?dZc~
zeyewZP4zV+CO(F4Z3$~trK}d!>YFRFhrP*(=BH)lERLF|Nt2{_o`<64dgrd+sx2vL
zOt^1;N|K-%AV~)MQTzfkr$lF5&Rr$6BRfK{KPljbm(t}=CMM|QGT~SGp~(s#8mrV%
z<W|8CYqpFG*jNDvWXQ(Ow<^-w0wRX#gM?1(BK(6m7)G+<qJb=khhi6kl;?$D<?;mA
zhIdb*SdnUio*0jT`K*v;U*Ck!RW<1#7RxS<KdVFce>ICn_1b+lidRXFF}YkYFIE0a
z+Qn5a6CSRzrsQ2MKS&*MLc@J2J7NuCl@!xsrty-klayD85WX?xld{o~MCZcO@dPB<
zwkXks_OUvb{V%kWc);h`QC=}mRFSpOckx)AO)b(=64;Gu`#Mj(z`u(_<~JDF#0<6q
zX!3^|c_i*nwem<c=|t|;nH*X)y3dTZFhQm2O*GCpX{NWF{IpQ<Y6qZSOlEY$OdQ0o
z7o#tSeVX^7Fc2pBX}8?EHfkalQbh~Ho@nRwtXlZa(U}EtuVv$k_U4?7qZ9k4)_hsF
z7DlW~m>!hxLp=1+kJ}6w7n+~XTnHpqH;<U;s(Q>=KxFi*m<A1gED!KH;4(1gJhH_}
zD1i`d;^R!+QqcX!-%YVi)|m>Zyqm1@|30W!z$Mji8@ZYkf5k<tkM=~IoY^hD?@k>~
zmPJLqjTzW9AyKE`1>%Uz1ZLC&;6I}hku;>vh*j+`eGK5fN^W6y>Qj4F(>2sJ>J+ss
z%TT|zB0A9{>N}%q2GT00hKaNoA{Nz2V<U*(kmSZ_Ci;6uIL%L0)68)bcaK5u%o+bO
zgEpZ6j_-10?i<J~eiD!I2Z9S!IJ2Ytx5dmAAfm5!V~%PVq8>i<%ITwP)9unBmA0cI
z6rbHjMorrxUNbciXH`QzE4K?zig++R%l_zblo#4hkT7L0FCa0y_Ja8p7SG?K;*V!(
z{sJWMj!&$HqF`KSpSggzT7_1ue7x*8FQwj})Eu`gBVa*X#%OUQ3BC#B!*@b!+$1Z6
zP}EpfddBh5t|&>)mf{e5fIcMR2)}8JG+8n6)faWn<A7ucS5+U)s7Qg#otK*~(}Sq|
znS=S5j%NbjourkO(asb3381em6$xZg;fu!$wW7C$EdxsSr99-Vrz__O?i@1Otugd?
zy=kxlxOH8#0CUX(<CK$Et=vzy?a`AUdx&=eA;|2Dpr(8&YiG%sbczzI?ip^%y6PHj
z;-#vdzpw58#Ev8dMp^`aYOP|Fpxs*_Bq5<4{kRLpJ?O+0yB&QN5wy+aO300qQiW5F
zFS_n@yI<>M(fX#c8zHzmj+>Oovk!0#$z_S=a$&t;PUs7BPl$uTc%H@2sJ?zXjfZ@!
zRPWe9BVk2%5B$=Mzd$^$|GxcikdSp4$9r8~#lBtcGdDrcmp4l%=YM9Opya)$1Bj>v
z*6$aHidLX?pj8EK>=Cz_`!bgQ_sN0*r_%~|u97mrP%iVWzEU`A23tvgOjUz%OOq0X
zx)O}jaC2NI_SaT_xxdjti@?#)(&2hwQqsmw8FG<BxjtD9E}&&+Q47G%s~7ArdDmBe
zt<*oo)%AjlWoX`Ni-154?{<%=<d5f51ghX>($`c#IBnwiW?oFp#OR~yM6KE1>Mz@H
z#n|KogHKEF-NH9#kDmJy>@As=Hw7h_$TUYHsFuEmEffTzIbqc0hVNf0!GgLOOQE%Y
zZ+5@e*nSw|Q-n9v@If(Ijc_j4GexKXavC1`Wt%O`)jTC(60)Cty1+O%)p|PoR{D3r
z2h$V+wFCkCk`LoIH>#TO&3^7JUHI~Pq{wnE*OnH%;TM!k+x{9-Dai9)<@my9g_yr9
zmv7?o>197V;v++K{&0cWM&c5Cvm;<WXcUATMU&GNb3<oBd+zLwD$`SVIgvk_qkQWJ
zbm2d%mk^8bW)PX}aZ;`ZPUsRg>`TKP@am+sD}oP_K2A=x&+-z6D@tdmA1{(Ugqck|
z$4}?F4%44P96oZPW<z4Hc)|;N&h$}QI$;q4j6zqdzMTV@!{Oj~^2){i?_p+@s~$^F
zD~n{q6*uQi$u;6-holoy_y(m_%|o8YZ+B2ILZHy~*?9PSx(?0w-&+IYxlGoq8lx<U
zy@Ozi%CZ%nOECLAFc2C?q@#vq13sY>#ON|56fc|i5SW#~pV)JeBPY?$oANRe@suU+
zu;=w|fav#{g)*@v?O$-KC+Fu2Ovbfr3*(?FPIY|()2CVoege*|9tuGU3#X6qoO)LH
ze(C;hpV_xe{aS?MM*T2kEppamMQtLw;_Jl6We3>BnTkDJK;}f;Q<I;R@e}vqfVxCg
zSJbFHA<*LWF&t@&81P%9oC=v?Z7E?ms#tMHM9XKB31R5tOD!Sd=(Z1HNAKQ?>C(e2
z2{|P1Ylgfh0=i2XTYlQS|0r1}EUFaYh&+#3{#jmS6WbxpaqUUy>vmJEIK1S46nhgO
zYr4MgtTtkD!=%W=U_gkWtF7wqDu4AsLKy|FYZFQ{EsMzFnmLibxh`ep@L*ylIep_6
zk!3cTldGy40rY3&h9Kd6A5#wrrnd@v^E(4!D=^t#y7SgMXEeVf5yUQ6*b@s9S?5||
zTREK8wBC0c_rDDNZ5l!LWYE19QL=u^bH=0z8998+#SG&K|E&ZKb-wq|&e3%PbFmu~
zhB+uqxV;B)0`r1k0TGK8vsV{L62{%swCpx*wZqoL_oAH%bmYbGs;NJRQHRsqs{)vC
zbu(hY^0*sOQ<KTjlutU_1W(9l`h+q+Yo5_<WM4)FMDhe6i{Fd;Z%9d!oPQe3d3EU2
zd0*yvB}N<0*P88V`SOMy&F)jQJ0*zTjW7=3@@No9ZRYiLjwY1=i&)A*Y}Obt2wFjl
zmZk@@HGAFiD`$JRrqp<Xk4^<+$)uVD*TYK8C+THJkBol|Aiv^RkTDqdb7_z@epYlH
zkkzb9>}kXkD#ZW{48D;gA9BBJRb_Qqz-_1fChI<@Py3TG^tjNv&>&7l+qy6#oDhYF
zR5i>RJ^SeJ5403q{e&dTV9grW`1Y~515u-FU!^{H1#SGnT>)+pq(L=W-V?Osy7v(v
zylKZeOib&v@632UNJYCKd|sg7U@VAmoKU;zLnDf%=Z(|8^V2VhXv2Nr0@Z<BjrR4(
zZH6WAOh!>t+uc&3Mic=A{J5-sHQ*5?lIWCnubK)feXFiO3XhGTfN+=*qQM;@r*CXV
zK9uxA?Llbucl6&f{XiP>%D=3x!m&CqAq#SNiF;9sa~?v!JY5h7RenhO-HD6FG#^o~
zrm>)p`v~?%*!G>C`GGJiRYioacK`n2n|7ntQ<Fl^)%&L8NmlN$nMB}F8D_JNd>rPy
z(jRo`Gvqq;7W7ytyLpQf>)T8OBV;s3pFeKz;_IMRC!k5^;m4v(XM?~_j)c3=TKM<M
zIu{Yo=={NHf_he5swdJJ*HmDq^`BQ_gx01&)X)jSx3X182SatmL+rm3Z{fLndNOnx
z*s9V)_z;MXZ0z%ze^eM@4MnX?b!Rvvi*DO~(q1_$Cw%1n0y3-1Io$agrls#D5rvgq
z9HGwCX=zX@>w)f>;0BAcAh*CI1R<!~V_%oMCE~&;qg#WYAJD}&QuuqK_Ue^l)Z`WH
zWhJE~lq_&?p`8{VrOMicg=gYIgdjrA8PF{HiPpkvqavpP9{C4G@it-6F)wsNDBiwV
zZq4i9!g9n6sVL^j+^en0*UU3+JgjxPj_qj8tS_z$A$Z`S3jc4n3xF$NoK!{W(`Rum
zFhvjvcRMh2zvqq0;Y9~xa*pl990hEu6(X8@@eFn|>A)<>*kM!}b6XRrA%1@gH|XE2
zmSu);j@6q*ZuVPoh9mMTLI%NkLE=KUA&io`yl6%N8BlKKua3DTTi!M5{qt>&-ES9j
z*q5tI%B&eTN2V<1VT#5a`ecG6D5n8lY<hMp*ejL`t?XNSG{cNqvhdh6a&e}n#esVG
zq*9MhnF1rLESM)L4kTR_{=Q_djA{WluSUQczJr#&HqXFXxt-cVMo_3c17hQ0)H3sA
zEwnRNx|81wNDA{#AQ#W9!kPZu6p0{rpjkM}t$Tm8#bu<f7>IG9G_m?eNz#l8!fmVh
zQI&coEI5I@@(1@JDT(cvzTz%1u-M0`?2Bq*&N>VQza_3(N}-JjxL)F&(#ONmg!!=M
zk0g@WRbjiD|24DQ3=nCHt?7<ai4VAps+J}SSA2H3HmZL8cdenDm3Q&d2=ZgHh|T;M
zR%(D1Md(DX{gZT#*?2(Z>UQ^$twkiL?V8Uz={HzHGUr{sszF$aCY-FpTI{b+Hmf%^
zQM&-Lw(cj!r8m{Hh`rMOix>pTBUwxF`q@Mm=`Z)5cjQf-f}M5{nIS%V)ztrqs^y~%
z6|x@_MSmsf!}1b8)iKA#ruRpX%|uVC?M`k^d3Q*x7>z$BMlc=DB2C?zE<mrRO35M^
z-$@q+<S@JK#cAhlg-k1xGT_Jy;TH+Mxgd#mP3;fx^A*VnPyb8pdWrm7UF8D#>SJzg
z?o6&zt}hA-tqQ7S11$<II<4xbPa#3yd|tl_qLoq3p_7THmAna5&qo<|CHT0#;!fAc
zIG2>Rx3yvDbWz{B!pVHuayS$_r?Hh`Hyo}ozE05hmCYA^ENdDTcm4aVT1yb&1Ayxn
zLODqPAk>lgge6N}%tclSNm;2NFNrqJP=zXltjBI|ZD*7p8Myi2%6dew32O%{80=`W
zUM<|o>fImfc!Vo>{fb?mHE@wSk8C&HcR62<oHk{p3R1{kKj}C>T)Ns2`b!nQOPnFr
zefh~fR3YcBHWpWaK`)c(Ih!z9MCP`yHfdIhjxAoml_5AlbViy+YUQf&T?wYd%*cWo
z3Ti)k*GTb|Q$C4iwUrvYP%i8sh()D4fAeZC-6Ayl8F>DkRI6ku=^SpxPH)F=m2Xi$
zpwWWI!d<UJ5Fz*vRJ~^>bx6{8jf;IUH}dkFCC0>ZuevhIQat}&Tb#qrM8n1p978>y
z{aT45^~cRtFff#8Vmimu8p>{K+~53)LQp6Q83|Q9IJN_qe4uC*={j2^Z723*T6gk`
zCX;IJMQ^@p&J=ce^Y?FWH(z1dyYBJV$6U_e@VsH`<a9$>(s!OVZsBv(Kv9ql+}!;x
z9sj|4asQCnR<Vp!pU87Zr1qDI>Rr)`?>hIlJiIt*dlU~NFG(zdGft1wdq+CIj;vn}
ze`OP>QCiUy7<S0|p?FVcy_+d|oBzWc-HnYhLO~FgIVIDdQd>tI*?T(02U{P}3k~aG
zY9G4oX5v2H{(NfiySz=G=xejKE=V}$;mW?kL(8p$Z&dYO{K%20gXbdj{>P8@X6<4U
z&iRArxZa=&Qc2}fir@Gdj4!HqBFRJUe|TD&)6FH5tVc*9|2QhFF*SEk>6KcVZB72m
z^KmYr*C6AjzH8=cqnJEFc>cSc?MGGv-TO9+IT5YG2WQKIx&1T@qb^mBm0MdL%fE)K
zEhB{w!K5=v)$0vpl0=xIwUIGF3eSJ&g3#W5ztEWyDXUhnSSMJx5CPw?2%kqDPMI$y
zAd94x{*~U|&m?Yqc_i^p#tR7<1r;6lm8chzw>~3oHnpV?q3Mg7Lg(pl7XC@`|I^-g
zhBcLc>snAzX9QG=pn#$xARy8^Is-O}N(s_}paKa2kzSGvcBSbkf<QoqPJn<CLdOC@
zr3oPf2_e!62#62@fh1=K|2md)&&TuJ=idE=Ckfd*zp~c5-u14v_fCMJK2g;S4%cdJ
z_=7o0DJm*e?<Q-zCHiXCRqeZXXV5LtAHSbSo!NXj{J34A{OKz8u^O)H3%lZa(e$2M
z&+X(2U=U26k!aEH?L{L+ab0q-Sg%SGfwg4M$L+29E@&N_G=nWVr3S4PNx`)Ccp0pf
z=7yd7cm81^XMY>3LlmCX;Z>T>Qk)>KVBGnn(^m^!YFRDPn7-KE?^@8>`6AXBX}vMj
z<aulJx}C|&*+e2Mbe3f<P`4H_S(6mEgG%)yKefcUslTfTiT-z{tJl0bVNy&U41Q+V
zeOLFrnxcZri{3Y?rG9yxkt1^2X+Z^)cSdVq#XZa>zhgQ!bPw|vc5`>moFbp55V_33
z^-Gd3Y~&}-njR2`hx~4r!<msVv{Mf1K9g(9x^r1cC7$L2H)qK$<Yzx7pSr-&+r7?l
z=4CkG%*wD?g9V9D$nOo()U6qlbZM;^M6u{PDusG?8Vd^>x>rM-<7jvL&#+1>E2&R*
zvpg*ffsOfhhwhljw!J(;_H`?3T{i$bKvpH=v1auK(~)K60$xs8Kx0H}o-@bo335EH
zq0(f_w#Bda0uU}i*%VZ4Yiy8onRINPjn&+-#c=N3e9p~knF*`<l!@}YXPn~w#`AKd
zKPB4J`=75BDsXP!Q>3TSDF%l(#6NV4DK3Ydua1o@OWY;{nY^w0+4i)K-E6gcYpBzX
zi@Es5e|!r>w@z3!u${=Igh<Pa|AZGnra9dvMB5u~Efs9B3C9Lj&q8s-a5}XPl7Fuv
zr~%{Cs>)TdS?z~#eiTwumtQor6`ofwDzRZ{iDF^gxRq~`|Czb#QPJX%<&aOUws1SL
z%Hy30u$XmIZfd0R3lrr&CHFiJx=AEFi&@7TxI!xF4l7btX_DM+4SZMwRIg)u_T2P)
z-|Yhw5mm+5QKtRwkv%#r`|WCC=bQ1SG{GXb^l8C~Jx)=V)!6kHp;$c7UMA@~5%4r*
z*;Ss7Wub~u((?Zfg+C_ut-{_hCmQ_)Zl*s6uA_Otf9zA2%Q>e8oC6CXQF~JL&ewsj
z%wYfe)z%{NH-q29_rBXJoM2Sst9G`<?AzqNe8*<>i>~YJR$bpUgR;UCWi;S905Nhv
zxvrmx(Ej3{U#;Nz_5FtyuLr$sO;{CKvaKA@M&VI&bf6!MQ8`fr*9`%r3Ezt8EnmO>
zWhjaF1OyznbyN*IZH&HVa_}J<c=lp+(1q&`{0me(<HCO&jiC8~HQ9SC4@^It-FxqZ
zY|(PayCWO2fL>`WYtxHAj>ZHn;3QgNJXN{%z<z$kB!}M(8M9OOuriQ_c*Wb=osct&
zKF|e~`-(DO#`R8V^$R=P1@gWhR~A5`vAn<XZW|8Uru?vm{2zS+Sp)e0oBUHh4OUq8
zoi%Vat5DIO_KAPC_`h7Skf-C{Tho`r=WGB3uy$$KxPpD(uU6PT+3xZ9g3ABE;&=Zt
z6czSnK7{!FI2T|FkuDnr%fj|yRlfW3m%~l0)(JTNe=?m1to%>)PON*>)W?a?T8iaQ
z`}CXaC+4unt`BE~0_9xm?X<&U|C`-U2KLK$PIB9K-v8w^0dl~un6;Jsx+}<Sz^=r&
zxc|B<K7i5F#&jS3YD&I<Db=>a&3_sqU`jE-0Hh3mfS>;uj0IpY+F>!j8cd~#uy<g_
zsQs@4s0GY|ZH80()hx7u0r<@A{BLYo8?a^inCAXpJ;MwbKuoIpuLEH32i8WahWP8+
z&;$j`D%<@J{yG3Uur|mHO5(3;BLxfq+#GOo{$KJO*Uvs%g1&iy33^?TF(-i$C%^N(
z&K*NEGBhb@L?mX(=b^|aqlbQ7H&&dYbhBVtk7+MIs6?KZ|J0iyl#R7A$RDI=4tJ6=
zcU($VZ_#Nq@anhiGAA|b_%}9Mn(KEt%T#l+=jv;MGarvWHddbR6Z-Asp@ypLlcbo$
z!b?@J^Wj+x4~+Xeq+xr-b1bep#U<i%J8?B|U&2d+Wm3Ze)k4DsfqPbbzXgDZOTQEN
z?(S;8se1XNHG`;**0jVSo+@OUN8xIH*w0m<ma_*JQ~mPQoP=P(NN)Qry`a<!f1l`B
zo_0|{6ps=}SCy)R%eRI)f5Qetv0|cKTx9&pyf!+1XrVw)1v>?v(YtgjrX#*?dFDFD
zjhOKa4e$ukH3B^aRnl~c@$wZ*Dz3FT?_01mKfcDy+v522BY!@KM;=`BOtmy5DUf?(
zeF3v8**9BU8m(iv^l2@F3E@$@M_aUAtP;3$PkK0kLENK*e%cP}9y$Axx;FGxu!vY(
z_NWqNR3`jD!^1+h*lLQVybLD$vDc&0`Pgu>%zXSej50X}tVwL*$3OXy{OW{jgOD$#
zukKZ<d&CKm^5wys*p79#koty!JX#D=Re$6|sfp$dpY(W&r@;u3C!o~>r>8s9!<1;K
zH@b|^?&y1|p<~?jG#S+VwbFrGgpw({Kk9$~isF%$0_LV4|9oS_U%5l=8|x)cN7V*n
zN-4g${K6934Ix#VE^$K!a+ThZWmtIi$P@c98p?$B#tsjw>H{qrqt!9j+}@5_cwjoq
zr`LbOU*N0)j+g`QZ}I1}-y!mZe6j(eb~=vKsovaqsGP-Cf|Eq0gv!;r)&NFziv8Ni
z*jsn1q>9&bg}&?S&{nVcV`Ji7orm{ESB&Ey@x=3Gx}>vk-$Wk{%}X;XF?(Ub5N)O2
zqDlAEQniJ+MpQZED3!gTYuYAVB0fGw^?0(ug*T1vKy#T#2lKo<9&1`?EpCrlVoLE)
zGmCRXeK^|U@cRp1Y>{V_w3B`=LbjWq8ZW(Gt59UGgAD9@rdn>Fgc$nA>up|+*GKKz
zUVGOH+q2QpQM0kiT^}T=%3VjJ6k^(p*{)%OcnEy@O|ySn!iYn}V+}xI4s<Gl7L}w@
zNkV;)by;zl5SI`w3+>qgJR{Ms;q}NN{Gj;Z=do7HgROHHn4?fD!_)!AH1%d9NRr2$
z;2glK(0|n&LwlNQok!7IC|zBa;j>H%$tg-D9_TH}8(%^_YTsNldpx=|JUgt#sy7%C
zHgo4#K9g*gDKZ;tzWHF?xP6UB%kOS`hyBTH#Ef1>P(+;-ghRVMeJz*9(8{K;=?T1e
z>2jtO<HmRjZ|QTB7g2ZQq>}g3z?`fNy{fHCSstn0z!e0Kk9GFtJOXYv*GVTWgsO)!
zQ(JdTMIC&corEHm8PdLxn^#biV$Ef`JMJET!w(BKmwftL*>)g-8d;V>pg)<9@--lI
z>Ph8H3hDbjp_zpr?84|x{B<TO2hA<Tb~r^T8}^_)WEQgKSV}6nhDL)s{c~{8fbhwA
zsEWR-^OgEYMup-BFZvz>2ft^N9k*)dFdF0l^-^ORVaZQLr0>r}VQRB~uvqDz5|>A1
zREw1Lcx}dXoeztR8jUQ(ETi;oqtW9&&B?j7Q>10r6BNPEQw2q(i#eoN?9p_1l2wME
z{?QgwJ0!a2GL8d_G#$KCQa<yV?t5x<*Ju28D3!2~Dp9cv^SWkOhY<^Ddpl`G=#^>S
z-^#n2#w*@5lnQ7UFkEFrPKOz}!b-QLG-h-FS;a_sK)Ptm>GN!?w-o8{nQP#XK1=z&
z*SVA{71uj6I=2MdRefx_+R#+T;GI}x+qeu}xzL8QO9Cb}h9};TQ{lb|?y&Gkd+4&%
zRwuPDTT0Cl^1?1cCI$IHoTNO;sXQ}Fn?UbHAm6FQEKO?fajN@V{wn_yJ8ja6Jk{8C
zT~zD6Vqw)p-`e$qYo&*dtT@%7$jyL5Mb<@Hrt$X)5Xy23M+z6kdq*0V{FYLUo$sTn
z+I-gDbnr8p**vE_nwqqQ*FEl4ESoDcx=YS>Jl$>%TD-~OX3xOM_?(DgYsQf3^dTZ;
z>x;n~#(l=Sn0J`#e_wrboV=N`P^+7z$I{`wI9jNK6SSVHo%$TmyhTduYIAxkVR2F7
z%{<nSu;WnYUCu!GKqRlqh~t*f($V6P)*In@j39U0khg&@ap=k29_<vrqwE<wc(%lu
z?NlI=Jd7=JX{y+Oy!hPREv=gsjWkZ+M)W`S3yyYNa0+VP9p7fgNF&e=dFG0mx&>HY
zCpJ!(*fzymHg<o&$kW4SV*&<7fhUfqvY$OVjeX$WSZXDK@qd@#c(hP7KT6)4Q<IjJ
z$nCAIndyNuK2D<)FcrL1_hl4n=1n6%Z1}O?=V%qhIKgp)M!*UR3QNQSSlz!+6lTE(
z(0k6ZSFesB9)+4|(I=^sjZ^GXdV$lJv&(Cw9nDSenof^8!zy5z9RbRtOk7Ud@f>tG
ztLI_OBYAef=oFmyt|PQRp5k3WN6BYj1y&?3Q$N4mvc)kv<xcytsDjEaPg1L!gTwVd
ztn5gA#7h%5;MYTpseXg)t;X5dR^C)R>F;U!6RnfD&>l~L^Es%%oVi<R$U3!){<)Ny
zxBhLJ+wz5TjQ)mwR-ng=IrZ0g4PC)zdwIYxdn8u3S8SNZxD8q7I7Y|n!Fg?zpt$yP
z{HWWrXk|3~P<dY}`eT29rRK{+M^n`2Y0vguNCx6y$3NIY!=8r?5@gYSJEV=<sTaXh
z)j()ulsju%L6!%Ki7X_t?%c>ZS>=)uwpU+P0&wy8<$@T9@id$J2eM`{#k!+L+ll<t
zvDz3Dy~bNNmth%_!m7cQ3Eah^yl<5@aF6|_BdVT#K&Fax%V9q5{^iX@3$;DD_4wdk
zY|xRLfYdyLlCGd_=x`4{M<}|}XR)#?*=sV;do|3Vxe2B#c}=BA$bd|6=}sfJ+WX3^
zCBM;O#pgOcgt#mUmva&^PEkzug|3rp$}Iovij0Cbqj?!fxZI_Il2I9CuGS4-45rSW
zo}~(P59^)I7cpicfDcYP3gw~DPjG5$Ci?4WJt2x+Tc`_B8!{Ux3$BR5BKEeKrsaLd
zq!Xv|u10segmT}*GMh%>5VwyPXoW5nsk~Q682lNzO+CAh&tN*PNcpxOMjXuUbmmb9
zVRF8EnxkZgKBvhz6f!id92PUua%GIhDA1`|Q#`SUg#XJQgQ>kY;uw_Gxl^y<c!@fT
zj`dr8UC>lDw-rIyrn0m266X#i6?gPm8v@gp+x6ydUg7ln%d<U6t}_t@7$!?ewP2lf
z$-JF+unY2p^25+#hb84Qp{aR1?Bs_sJmqZo6Sh^s{UDg;CRH=L2C*09hGQsgWlp38
zj78<m=0JJXS|_pGkn0zukmq@@lf#M%T{-!_GnH=ReGTO8G<4lU9pi7c4sU#6aM6tj
zCTIN;yF=Y7YqJm?Hy>b5ajJE&f=4R;mEzvN4~A|e26m22*YcPFgXc1`58!HP9v%Ck
zx}L?P;}FcJ2ai7Z0rcj$qfAHuqOf%28t|+KsI<%G<$)QUI)Cgc1nYr{PhSh-3&wpE
zFyo|67l(Vf2(NhPYdPT~Z|FD)<|(xKsc5LrQjO_7;S60j!;JEmA9~4GKeVLVr9cIC
z>n{&=KC-Tvf0%~vRSg^^LtHFHE~juO4LeHoeLE73%IcFQvY1BtibIlP5pL~Mj`{bB
zY8wP|Xjav^l9*>Mr*cKx+G^^bdfk#kKd|c!NM=vr+mC85&o2-;YP7K%@Pdt91`R4I
z2E`K_>u{}p)JLb4TH$x|vMs0S=i5q2?Ky;kGl7hD`h=&V^K}O`J@}Fg#zu-v+6gn|
zNbDdqzDX$SM2)EuG`em^A=gvgPC5zPNS;Dob{O22hPduff<9<21OIa}WXMZdE^a)%
z%Pf2{xr@^baR4w_<!T-#R#&~j6U!Epn{?Z~5LqS&pP&YiO~s7D2O7u?yR={%@dJyA
z9pZGJBWm<DFnC-`Bf+3ONd9Vx;H^iCA8wIy;taJLa`WvoYq-G$p%<K~>DT%=G*;bx
zA01>T>wI*Xq;;<74IjOUOtTsZOu7F>QSnutbhitAVQHK&#C8a$Lh!1bPN~R>4Bvmy
zwZ7{zD!4|Azind<vRyDe_qsN`d8mW`675zs>>MRV|6sAb=H%sPI5avsyiudH8)tM?
z!3<ZQHj;PB{ouR)2jaGyy(zez?<0<z2S+g<xLr6mE4KT^Qt*OPSlfCT#PxM8ZQAtM
z`v=snD3l4J+#)B{oL8%uT|%(&(~t>!XNtt*01l(he3}}RF!J<TUn@|II$?}p;K{+U
zl8BxQO<TyA#YgAV3hS1%0nUxW&f5ssv1kDn%FS>(VG(uxlK#$_2@TUg+twFlg4gZn
z^XhmJqY|rb?jRAX@8D|qvYcGj<5k?DV7A?~yxX8g%|Na|$~&qZ4%908M%iMUGuzH6
zFZWfOj!7KxK}KPvw*(HiCniZ82|((>%+)6Y93z;4q@Y_nwTD<9@=O(-xn%tP5GK-n
z&Ord_-s85bQUVX5Kgu&J`CW7TG5|^s&6)|PIl|Bt_2hZ6xUl!{ON8#td->T*iRf+U
ze)os3jD42fE3-H4b$judEtdX5k^DMl=AvU5%|efz6+SbbuoPA-Ix3Cx<z958IKG`p
zN)7vv8vC}MOx5D_?8f6u+%VZ{h!QO_QX5L`-e=aY5jW)p*omB3XT1il9OmN9JYzC>
z{si?rzDn2G9r0{Ka#5dzwY)nr)3PjHYbhjb0Y}KT4_7Q3x#wOyDDI3Xj4eV{)Gtwd
zH~u}aRQmvthu7M9g%E;ld0|(8*6I`^c_tGQ(!whjeI|pVH%(}ycpH`LcHdpsrBB=A
zjg5OZK9?9dA2t1AB46PlQ`rm`qcDb@7N@^zuLFu~bFb6OB*>a7W`B^G246xp6c8&1
zC-euaSM*koH6<gK1^wzD>|&hq;(mjnjb0`?qfnNT2@1z2@mFYRz6?=4Ma@~K*|LwU
zUO6GV7hNZn<KnBg^}lR0uJO`TMog7{3`@4nxD|9lL~=`MgGMcTU}0wYsZ4Lc6WaO+
z?>CCq^ENn^ymF?vX!RU;61k<B5q1neWi!jNG2iwvAZqg}Z~srZCYcWg^^93|(+Tv7
ztNo`9#l}92$4^cVzZSKV%J<gHhs``fy7jmhA;x!Hf<2T>#+Qh>40B=ziA=MC-^C%e
z(aJ}AEo#{{j~G|o^QEFX+s?%}gfFMoQG%kT=~PvtDy>R{d1GiSpZE!yn**%n4udxD
zz&Dg9`%iD)(f7EkOW}l5plXpr*PG+%mhhk|sJUjc`~B7~_T5!^q2U=`+Z|>HX}z%w
z4>)oh4QYbowpqX4V;(-zzXX@dNv-5f^{`DvE<1<6Rl{RHGz<)vpw2DXr5&|HNAzuZ
zRo#uQua<*bi@P70?{*0pXz!t@apVc`CCOuxau0|BDubVUtD6GEf-E5xyeKb3iG8@Y
zZ!MR7Z!$YAFt)v@KxgO(c?+po19pb>Vm__FK~9k+CWmoB4rk3Ry9>nxGC~U1B8_7$
z(goYyJ3Wv~W7<Nelpx}v63K}B<Srip#~IdGDKf}{z~Rn~|FhOHTf$Hra{NDNbmtt9
zz^K(Nx#;tk=Qo8z6Kgi-EL;pokGGS#LhsNwS0^3BuY0P`&}R%;2RwCzEY&-lD+vja
zcPyv~G{fIs21tx8m9q#u>w-@>dzj_)tdVxjnF}AO)w|~Jw;nTS@ME4<@(Dg1uLR8b
zc&@!;K>|PtCoV*_|M9?F>s;WDm%Me3n4RigAC09EB5w@?=`=heNvPo{gZ$4d56NhN
zy&XBlFeXy~#&V^}v!X<o=>wfOx8Y;_RPDTwva<Vbb_q?Z+dXY=ZY?Xjs;HvWZ;VE9
zP93m1cuywsN<oIWafVpo(c;7+FS!-rW!r<lT;XnEgc>_O0OxM3AD~>b@QBik9>_;B
z^L%-z{t69>+o=al2Zf_<OfQf~q~S)ctTT7^4>);HF=UkInpR2<j`Lx3Nt-oX<qlTX
z9DZJDG3bCL4JKWy5S;8e))wf{h{_P)Yd-<)aYDy~?ao^*nQk<jB-0%yfuL&<UB>Pd
zsoQ}KtlE>yu1}ZG^si%)1E@DV?Bpg~;MKr$f|x)ShUHX@3}wK@uiN`%w7?<MXl!N=
z-*f+ZUN3uyQU7UAjTwIivhNNaTDlsQZT~#{iE)Yj+{t7FrQ1+UrEWm{mgZE|eJfeB
z-wN@AE?%Fr6+F>Z%geCw?xsSEp6nP)fZvkUFuXf%OpgCSfxfUSf6(F5N48m;Ojz@7
z8g)po-MBnkCI#GJ9}TVK{O!N~cf8wPYbU0EeZ=PM&;$pcCx?-tANlE%3WvcWRt851
zA-(I;GLb4AIQvuI21rKf`YnY6upG4BWO=|)(1aa?v^=5{XD2nWEnvkTg~u}f5^+S<
zQ<C^^iB^$9Q)R)LhX<mG+sh`bjExG*n5}qb60uD^^>UkH*R#7yW3+HiJYHM`@+9Ij
zx5`1REDhE5UP|@QnkXbM1bTOH|3hW795Mi+ZFZ2%6hOsb-ip|@ITCHi4AJw$#ZkIE
zurgv01E<9dDn%?!MvZ>d_KBwdT~k&vL1Hps@NpdsmHT>fR~#FGxZc;U@7*ofU!>PB
zk9UQ=XKL-5@V{L=g``GQ&W{dzq*;o5HoQz_GHR2HPE5kv8*C-q)0Y!Z(&9{l3!o`$
zzwDLHCW#Ww*vnh^#uwSIBphXio0*|WsvgSbIz`k6OS1H9+6^vx=DNGR9jvcx;Z1d6
z)obUPA1H4xc^!(3%7a+-F4Za3lVzmnby{iYl!-xBpIU9&=a6s|h0E@SaSG6yt-j33
zAd7GeD$oI0)s|^$=d9FXz>3JY;ef|b%{ZEy<~|X%==xg9^R+@Yk<_hTO`JGyM!*O+
zJX=0Lk3jP-dE`*=p4mUH7zNcCOqv_^_bpI1myz2&L2VgL`CFPjQOK;SU8%A~o>!3V
zmVD%k6<<j(XqyU{d4`Tf+<Ag=N}6;vXJmI1@gadNmT^jtHUNv<HX#N%<=vP4`25I7
zmDl__ad-u9Y!?BL5$My+<TCr^Z7g&97rhHZQr3&(j?vet3#T?@j>zV4ot7wQ{Ee*1
zHr4?5s1mOIfYj>F9&#xapmBMY+<|$9F)u8gdzu3Ez@XDh7YQgE3tMl@_`>r-N}#jj
zO1zUjWCUou#L?i!3O@BRp$qV(5HE}sx+05r!?=eq%ryzl#$4<ozEU+>v>%*5t-XJw
zc(7fc+xv1`hEEb<AEoDzg&rdpJ7eJ~clwbN{92DBlu6kRxf)URO5{&9J%%=PDL{{j
z)z7xBed^AhxLAixczmF)_S3?v7>Xffps6$hs*&nhH8UcGqliI#!^;<FOe|JPWxg*^
z5}6i0_adN2+vowZ1#e4OuxYZPZSbwjYbSjXDG%)g!u6{eXJ!)LkYuBt!yHkHEe37N
zF%Ci;=A*fUQ*DS|nK5GYvleoQj#z4(=H;6`e8FMv6P@duOS?HdOG%j{&2_G2X}C}i
z&K^8nctXQ!5Y?Mlv}yCPqJ=)9JGyqPId*O8vHW)*uN#)ZmhYU-n-km3_-C49l7Vn)
zn3|7jh4spiVkRsNwK&61XFKRBb+WWjvgsiC=$O0Sw2PtkunkG$WU$_z&)LtcPEL{>
zrA#;V-3}}&(_I)<sBN5}8j^diB<u`5&6)Cq;*4fq2e1i2IF7DAuPsO0B|NYc*(0;S
zic-zgriWzAe6k_6yepslqNo0(Fqp~~{aMDHS}N_VTzI_}3sr%_LkkvL_h1WY5riPq
z1_C_{J6tlNKhqTIRO9VNbyMsDgl6YL=OEXnQ)qfw+K$WV6C++u{h@4vakBJ6-GpN-
zqHf!HB97IkU>YKfmM&V8wXUz`%94-i6xuaGl@P6>$NGTVvLmc7cvh1UXIp%R{>X*(
zhw>3PXXXxL;x??(85us#4ZoQp9pQ}MPg$h%%sBUI(U`ECk2~g#^%N}B$el6%cRs<2
zpBoejONu|eZA{=!X)B1O%D}3ItF5gIOd<3Umx%Xli?76WJ3w5U2;?Y!jUdu#4L@@o
z-*hPhr4|8*{~gR6j@!G>YKWpxOrgZ?fL@>E91rPg+;Ac!zhS`FXlW>5K@8rR3YXr|
z^>k1mU{r=2|9(&Oj!$hCkQ}P2uDmmH;0&Ys8q1PS4_OT8?_a{3ze)<u8}0yP0OJoz
zE~T4(gY<Y;5&cC}Qf&&)1WYP4W=iaU(B1CRqpXaQxC>ahj`K3k%7(n|+&nnkr|wwN
zl_al;Dlv{E4$)#Y)jqZ(vSEgN{Ap9HQMn#(R5GqHro4xCv2o|$mdndQF-rc#LExzH
zh{w4EQEgh;44WP{(E`KdTXh~yD|e<3ynUc{_H*yG+Os!^^!%<5Ng6GOs42{xC2n9V
ztOc(;Z~V`&L93oCZu}p?45*E3!+1Cf&~(V%EI{s0M4`J0B&9ZEYDfWU5Rb0=yH$S(
z&gjT6i&>Q%lzpy4QD*4^QvBOWCq~%UDyrUHi9;8*-oBBiy}Vq@SfCNSZK?+nZsmw-
zQ?)GA2M@+Hj%&O1^j20)Ia{c*eK_d>JY@>`=%Zi@eP@K^+33AtixnP{ZK`~ohY_e{
z>46;G9MibJUW#Rx@y|e8x%aaer@fPx>wO)}o|aM;-z5l{Tk&T5hzBsd+Br8i5<hiL
z;DX=q3$J|WKpL(~`EI-Gq+@}8>AYoz*t8G2ww}XRC+3Eb!C8EE(>2B9apj%;dgD6c
z$t==u&)P8An9x7N7!3LR>6jcxVATSiz9A8zy~Zts=DYhW{i~-+dd(a&jUgnRY3$XG
z?me=xd0~7Sqv2M&&U#&fG)`<ZE)YNN7(uTOph&eX+j7!t(MT3s=0sdyXt?rN%!54T
z{k$xzY(vY60(QmW@qvwM2(?yYGYt7v72Jw*uChOR5Kb3TZ`HL5n*ikc2Q0et=GV#4
z;AkCAH_AA#Xsa%g4#oYa>|e9}kQ+9k62^b~yjb{l`%ysRvm3<!`DCk{{CX--@fq#d
zl<aNTLsB~_k7D?2!C!KA?JsRuO%8abXp$^JSQrimQoeih%PsMEd@1pQFnk@7-R%#^
z%yFA`xbq~kM9=p>;FbHAo>nres@EX4)XrRsElSnS=F*JB<ra-X7v6Zq#7%dd%{O}c
zv80Oow@cW39-vB?^?r<)+u;SoQiSd$x0-D?^`!$Hn#O91Z(}zTdoGq_JNTDx%joSR
zOsWj-qpS}{VTVWGx<<Xhl?}&wQMRcpKrgdemF|c{sfn`M#8b~XUQ=E}8lf0+3j8~>
z4TyqgrB>pS#1vmT<!%W_u1Ke*t{FA+h>d1G2DA0;+2UPN4Wi3s%dKa;niPwZ!tVrA
zWPBDSceenlMndgnHd*0i)SdIm-k%lDF26Jccxui?qlNyYHf@zfxC1)Qx6G*lVJ;@(
z?aicRkct|i_uM*9b?)>`hOu|RBZ-i<x_zd93Cm3rZz+oj$BF2KbJ=&dlg5*B9&4sS
zQ_un-Y5GhdFMdr81^cIN*K}y~pFKlL8?qL$nxyrIoq$3RzW|mi$q0HLG9hX#UuHNo
znzyL<L@lr)wA6z$GztyMnp-3l<y#z!NmH<{hUc@bm7$~d7v7ZiP0^1-by>vHh4G0p
zgV8T7OcF(F9@wO9tu=IlI@P&Qb`xTfTsm-oFulSDWg;c+h*%G~gpK6&1Ux$@Zojw1
z#$xx~d#}1MCg%NN+>%=zo2?9z-1a(O7myoq%pK`<9zJ}mG3+#c7QK8Q=0JOfXB3j+
z5|vF&)a*SWBhC9$RMgG_f?e21`VxGa=S`;L>@$%%zJ9B3c*rbzXyTczJ)*)nX&1{h
znyTfnN_SfgQ=nxOpq(r7{O*<h7BQTAM3~6cLg{KL;Lj7q6F>Ht?7s}OS8%o89cx&$
zu;r@{Uzo_(7YAfzyA}T`Soh<nd~$*Ujzd|CuILv(9JC4O@z^8_Kl1abWbXmBr+B)J
z=}Hdp^#_1ct%_U&*w>oZ4&SP|-(Cy>y2!A$?foBqfX^<T`~~#Ita>WOH^}c#wR+7W
zKtjN&{Jbgx;I4oM_J5zRJg9a?tYdrriWMfZSRl_nrz`qJ0{Py}4*>m;iu($MeuX4E
z0Fvx18-AIlz)7I*?c|AxKYoQITL6;ct<`>oq_Y4do$X-%;zxoPfTqif!!|#(Z?6pR
z$wL5=9+s~3XZ#3B=Kx3or}E2Eg1Z75*e|{c`U;3(-=qBsKLo)Tj4MBfXcI8ngT&=$
z4hV8EkQsv{{|B!C^A#}l0#mQ=6Y@xqPJ(n2q?6yL-uM2Obuho#3dyhc0{BVW2jx9b
zsr;#=BLIr7pnm*4Tz!e=pneSM$G=zws2_v+F{mGZpYVa27^sPXni!~weM3bsM1mpm
zn=$<71*nOEtvf$JB%eWmC04LE>?d^&=)48n+`#6;pRMA5TR;Bk_x~3(;}1M)i94WK
zueyGo>+F8@WB%&nVX><sPnvY+XL7zzx4uwqr*+p0m2&=@zEbdj@2Cg3O5Y`Bpe=o0
zlLJiyGz}12|CP5ve*paf^as!%KvwycC4hYC>q_v28!$eA@d1nvV0-}M!&g)U<HOgL
z0OP~IxUeGCfu;eP1}M<}E24w`0Qv*y51>DQwXAQIJTRXI^Jy@j{+Bm{{s8&|=ntSj
zfcnzcQ~^wyzODqQFa3)PpuY6W#k(MN0I9?OKpocmj~-sNYRA13e;%;`TPD9=j{)|H
zf_<W33-Py0Qb4i=k}Xi71{G>hp#~LdkR*a65xnH;OHK*q)?jY^KjhXRRDw_mLL~^5
z-zSftLJca^V8sTk*Z|Mn14U*~Wd1*i%&vV?X|)F_9XEh`UaUG{YWZi;QP->g1(S!~
AfdBvi

diff --git a/example/index.js b/example/index.js
index 3ddfc58..4ae8f67 100644
--- a/example/index.js
+++ b/example/index.js
@@ -2,6 +2,6 @@ import { AppRegistry } from 'react-native';
 import { name as appName } from './app.json';
 import App from './src/App';
 import { install } from 'react-native-nitro-base64';
-
+import 'react-native-quick-base64';
 install();
 AppRegistry.registerComponent(appName, () => App);
diff --git a/example/ios/NitroBase64Example.xcodeproj/project.pbxproj b/example/ios/NitroBase64Example.xcodeproj/project.pbxproj
index 8cd2c4c..363fef2 100644
--- a/example/ios/NitroBase64Example.xcodeproj/project.pbxproj
+++ b/example/ios/NitroBase64Example.xcodeproj/project.pbxproj
@@ -11,19 +11,19 @@
 		761780ED2CA45674006654EE /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 761780EC2CA45674006654EE /* AppDelegate.swift */; };
 		81AB9BB82411601600AC10FF /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */; };
 		BA8731FA8F4AE30FD34E383A /* PrivacyInfo.xcprivacy in Resources */ = {isa = PBXBuildFile; fileRef = 13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */; };
-		D891FF4993729C4A84C2F7E9 /* libPods-NitroBase64Example.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 098BA51963414FC1C9E6DB12 /* libPods-NitroBase64Example.a */; };
+		FF36CB20B19F64C38348A6E0 /* libPods-NitroBase64Example.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 9AE440FAA83DDAAECFBFDE91 /* libPods-NitroBase64Example.a */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
-		098BA51963414FC1C9E6DB12 /* libPods-NitroBase64Example.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-NitroBase64Example.a"; sourceTree = BUILT_PRODUCTS_DIR; };
 		13B07F961A680F5B00A75B9A /* NitroBase64Example.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = NitroBase64Example.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		13B07FB51A68108700A75B9A /* Images.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Images.xcassets; path = NitroBase64Example/Images.xcassets; sourceTree = "<group>"; };
 		13B07FB61A68108700A75B9A /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = NitroBase64Example/Info.plist; sourceTree = "<group>"; };
 		13B07FB81A68108700A75B9A /* PrivacyInfo.xcprivacy */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = PrivacyInfo.xcprivacy; path = NitroBase64Example/PrivacyInfo.xcprivacy; sourceTree = "<group>"; };
-		66E9F03C53D7017FE9545A1B /* Pods-NitroBase64Example.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.release.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.release.xcconfig"; sourceTree = "<group>"; };
+		5970CB6C7B61052C670099BF /* Pods-NitroBase64Example.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.debug.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.debug.xcconfig"; sourceTree = "<group>"; };
 		761780EC2CA45674006654EE /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = AppDelegate.swift; path = NitroBase64Example/AppDelegate.swift; sourceTree = "<group>"; };
 		81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; name = LaunchScreen.storyboard; path = NitroBase64Example/LaunchScreen.storyboard; sourceTree = "<group>"; };
-		DAACC79F12F190ED23DE45D7 /* Pods-NitroBase64Example.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.debug.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.debug.xcconfig"; sourceTree = "<group>"; };
+		9AE440FAA83DDAAECFBFDE91 /* libPods-NitroBase64Example.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-NitroBase64Example.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+		9E8DAE6BEF6EB943E3A5C42E /* Pods-NitroBase64Example.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-NitroBase64Example.release.xcconfig"; path = "Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example.release.xcconfig"; sourceTree = "<group>"; };
 		ED297162215061F000B7C4FE /* JavaScriptCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = JavaScriptCore.framework; path = System/Library/Frameworks/JavaScriptCore.framework; sourceTree = SDKROOT; };
 /* End PBXFileReference section */
 
@@ -32,7 +32,7 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				D891FF4993729C4A84C2F7E9 /* libPods-NitroBase64Example.a in Frameworks */,
+				FF36CB20B19F64C38348A6E0 /* libPods-NitroBase64Example.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -55,7 +55,7 @@
 			isa = PBXGroup;
 			children = (
 				ED297162215061F000B7C4FE /* JavaScriptCore.framework */,
-				098BA51963414FC1C9E6DB12 /* libPods-NitroBase64Example.a */,
+				9AE440FAA83DDAAECFBFDE91 /* libPods-NitroBase64Example.a */,
 			);
 			name = Frameworks;
 			sourceTree = "<group>";
@@ -92,8 +92,8 @@
 		BBD78D7AC51CEA395F1C20DB /* Pods */ = {
 			isa = PBXGroup;
 			children = (
-				DAACC79F12F190ED23DE45D7 /* Pods-NitroBase64Example.debug.xcconfig */,
-				66E9F03C53D7017FE9545A1B /* Pods-NitroBase64Example.release.xcconfig */,
+				5970CB6C7B61052C670099BF /* Pods-NitroBase64Example.debug.xcconfig */,
+				9E8DAE6BEF6EB943E3A5C42E /* Pods-NitroBase64Example.release.xcconfig */,
 			);
 			path = Pods;
 			sourceTree = "<group>";
@@ -105,13 +105,13 @@
 			isa = PBXNativeTarget;
 			buildConfigurationList = 13B07F931A680F5B00A75B9A /* Build configuration list for PBXNativeTarget "NitroBase64Example" */;
 			buildPhases = (
-				698DAD2D36C86EE227AD3CC1 /* [CP] Check Pods Manifest.lock */,
+				B60AA6539ECF2D1C459B7F53 /* [CP] Check Pods Manifest.lock */,
 				13B07F871A680F5B00A75B9A /* Sources */,
 				13B07F8C1A680F5B00A75B9A /* Frameworks */,
 				13B07F8E1A680F5B00A75B9A /* Resources */,
 				00DD1BFF1BD5951E006B06BC /* Bundle React Native code and images */,
-				9E13E8199B99474DE1C693E0 /* [CP] Embed Pods Frameworks */,
-				65F550C0311E7C54C50B866B /* [CP] Copy Pods Resources */,
+				B25FA5EDB160A78A757DC68E /* [CP] Embed Pods Frameworks */,
+				7EF932ECA7B9FEC381831A14 /* [CP] Copy Pods Resources */,
 			);
 			buildRules = (
 			);
@@ -183,7 +183,7 @@
 			shellPath = /bin/sh;
 			shellScript = "set -e\n\nWITH_ENVIRONMENT=\"$REACT_NATIVE_PATH/scripts/xcode/with-environment.sh\"\nREACT_NATIVE_XCODE=\"$REACT_NATIVE_PATH/scripts/react-native-xcode.sh\"\n\n/bin/sh -c \"$WITH_ENVIRONMENT $REACT_NATIVE_XCODE\"\n";
 		};
-		65F550C0311E7C54C50B866B /* [CP] Copy Pods Resources */ = {
+		7EF932ECA7B9FEC381831A14 /* [CP] Copy Pods Resources */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
@@ -200,43 +200,43 @@
 			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-resources.sh\"\n";
 			showEnvVarsInLog = 0;
 		};
-		698DAD2D36C86EE227AD3CC1 /* [CP] Check Pods Manifest.lock */ = {
+		B25FA5EDB160A78A757DC68E /* [CP] Embed Pods Frameworks */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			inputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-input-files.xcfilelist",
 			);
-			inputPaths = (
-				"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
-				"${PODS_ROOT}/Manifest.lock",
-			);
-			name = "[CP] Check Pods Manifest.lock";
+			name = "[CP] Embed Pods Frameworks";
 			outputFileListPaths = (
-			);
-			outputPaths = (
-				"$(DERIVED_FILE_DIR)/Pods-NitroBase64Example-checkManifestLockResult.txt",
+				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-output-files.xcfilelist",
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
-			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks.sh\"\n";
 			showEnvVarsInLog = 0;
 		};
-		9E13E8199B99474DE1C693E0 /* [CP] Embed Pods Frameworks */ = {
+		B60AA6539ECF2D1C459B7F53 /* [CP] Check Pods Manifest.lock */ = {
 			isa = PBXShellScriptBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
 			);
 			inputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-input-files.xcfilelist",
 			);
-			name = "[CP] Embed Pods Frameworks";
+			inputPaths = (
+				"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
+				"${PODS_ROOT}/Manifest.lock",
+			);
+			name = "[CP] Check Pods Manifest.lock";
 			outputFileListPaths = (
-				"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks-${CONFIGURATION}-output-files.xcfilelist",
+			);
+			outputPaths = (
+				"$(DERIVED_FILE_DIR)/Pods-NitroBase64Example-checkManifestLockResult.txt",
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
-			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-NitroBase64Example/Pods-NitroBase64Example-frameworks.sh\"\n";
+			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
 			showEnvVarsInLog = 0;
 		};
 /* End PBXShellScriptBuildPhase section */
@@ -255,7 +255,7 @@
 /* Begin XCBuildConfiguration section */
 		13B07F941A680F5B00A75B9A /* Debug */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = DAACC79F12F190ED23DE45D7 /* Pods-NitroBase64Example.debug.xcconfig */;
+			baseConfigurationReference = 5970CB6C7B61052C670099BF /* Pods-NitroBase64Example.debug.xcconfig */;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
@@ -284,7 +284,7 @@
 		};
 		13B07F951A680F5B00A75B9A /* Release */ = {
 			isa = XCBuildConfiguration;
-			baseConfigurationReference = 66E9F03C53D7017FE9545A1B /* Pods-NitroBase64Example.release.xcconfig */;
+			baseConfigurationReference = 9E8DAE6BEF6EB943E3A5C42E /* Pods-NitroBase64Example.release.xcconfig */;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index 217f83b..1175979 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -8,7 +8,7 @@ PODS:
   - hermes-engine (0.81.1):
     - hermes-engine/Pre-built (= 0.81.1)
   - hermes-engine/Pre-built (0.81.1)
-  - NitroBase64 (0.8.2):
+  - NitroBase64 (1.1.0):
     - boost
     - DoubleConversion
     - fast_float
@@ -2674,7 +2674,7 @@ SPEC CHECKSUMS:
   fmt: a40bb5bd0294ea969aaaba240a927bd33d878cdd
   glog: 5683914934d5b6e4240e497e0f4a3b42d1854183
   hermes-engine: 4f8246b1f6d79f625e0d99472d1f3a71da4d28ca
-  NitroBase64: e9d09ea94a839528b94a43d3c500ad1405c8a413
+  NitroBase64: f35489547b9de21ebce93bfd2f5f39f42fe83d1e
   NitroModules: 70e2ff77a0b718e47d5bccd837fefe8a9aa20f50
   RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
   RCTDeprecation: c4b9e2fd0ab200e3af72b013ed6113187c607077
diff --git a/package.json b/package.json
index 55623a4..e3a3c47 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-base64",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "NitroModule Base64",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

From 16e387f8e39c5db85709a8a083462ffacc7a4c38 Mon Sep 17 00:00:00 2001
From: Rom <chanphiromsok2109@gmail.com>
Date: Sun, 17 May 2026 14:57:14 +0700
Subject: [PATCH 3/3] feat: enhance package description and expand keywords in
 package.json

---
 package.json | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index e3a3c47..4a4f7cb 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "react-native-nitro-base64",
-  "version": "1.1.1",
-  "description": "NitroModule Base64",
+  "version": "1.1.2",
+  "description": "The fastest Base64 library for React Native, powered by simdutf SIMD C++ and Nitro Modules",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
   "exports": {
@@ -47,7 +47,24 @@
   "keywords": [
     "react-native",
     "ios",
-    "android"
+    "android",
+    "base64",
+    "base64url",
+    "encoding",
+    "decoding",
+    "simdutf",
+    "simd",
+    "performance",
+    "fast",
+    "nitro",
+    "nitro-modules",
+    "jsi",
+    "arraybuffer",
+    "uint8array",
+    "binary",
+    "image",
+    "crypto",
+    "jwt"
   ],
   "repository": {
     "type": "git",